Below is the list of changes that have just been committed into a local
5.1 repository of stewart. When stewart does a push these changes will
be propagated to the main repository and, within 24 hours after the
push, to the public repository.
For information on how to access the public repository
see http://dev.mysql.com/doc/mysql/en/installing-source-tree.html
ChangeSet@stripped, 2006-07-24 02:32:49+10:00, stewart@willster.(none) +9 -0
Merge willster.(none):/home/stewart/Documents/MySQL/5.0/main
into willster.(none):/home/stewart/Documents/MySQL/5.1/main
MERGE: 1.1810.1694.99
BitKeeper/etc/config@stripped, 2006-07-24 02:30:05+10:00, stewart@willster.(none) +0 -0
Auto merged
MERGE: 1.13.1.11
mysql-test/Makefile.am@stripped, 2006-07-24 02:32:47+10:00, stewart@willster.(none) +1 -5
manual merge
MERGE: 1.66.1.4
sql/opt_range.cc@stripped, 2006-07-24 02:30:05+10:00, stewart@willster.(none) +0 -0
Auto merged
MERGE: 1.159.1.57
storage/ndb/src/kernel/blocks/ERROR_codes.txt@stripped, 2006-07-24 02:30:05+10:00, stewart@willster.(none) +0 -0
Auto merged
MERGE: 1.9.11.2
storage/ndb/src/kernel/blocks/ERROR_codes.txt@stripped, 2006-07-24 02:30:04+10:00, stewart@willster.(none) +0 -0
Merge rename: ndb/src/kernel/blocks/ERROR_codes.txt -> storage/ndb/src/kernel/blocks/ERROR_codes.txt
storage/ndb/src/kernel/blocks/dbtup/Dbtup.hpp@stripped, 2006-07-24 02:30:05+10:00, stewart@willster.(none) +0 -0
Auto merged
MERGE: 1.22.4.2
storage/ndb/src/kernel/blocks/dbtup/Dbtup.hpp@stripped, 2006-07-24 02:30:05+10:00, stewart@willster.(none) +0 -0
Merge rename: ndb/src/kernel/blocks/dbtup/Dbtup.hpp -> storage/ndb/src/kernel/blocks/dbtup/Dbtup.hpp
storage/ndb/src/kernel/blocks/dbtup/DbtupMeta.cpp@stripped, 2006-07-24 02:32:47+10:00, stewart@willster.(none) +0 -8
manual merge
MERGE: 1.12.3.3
storage/ndb/src/kernel/blocks/dbtup/DbtupMeta.cpp@stripped, 2006-07-24 02:30:05+10:00, stewart@willster.(none) +0 -0
Merge rename: ndb/src/kernel/blocks/dbtup/DbtupMeta.cpp -> storage/ndb/src/kernel/blocks/dbtup/DbtupMeta.cpp
storage/ndb/src/kernel/blocks/dbtup/DbtupTabDesMan.cpp@stripped, 2006-07-24 02:30:05+10:00, stewart@willster.(none) +0 -0
Auto merged
MERGE: 1.2.1.3
storage/ndb/src/kernel/blocks/dbtup/DbtupTabDesMan.cpp@stripped, 2006-07-24 02:30:05+10:00, stewart@willster.(none) +0 -0
Merge rename: ndb/src/kernel/blocks/dbtup/DbtupTabDesMan.cpp -> storage/ndb/src/kernel/blocks/dbtup/DbtupTabDesMan.cpp
storage/ndb/test/ndbapi/testDict.cpp@stripped, 2006-07-24 02:30:05+10:00, stewart@willster.(none) +0 -0
Auto merged
MERGE: 1.20.6.2
storage/ndb/test/ndbapi/testDict.cpp@stripped, 2006-07-24 02:30:05+10:00, stewart@willster.(none) +0 -0
Merge rename: ndb/test/ndbapi/testDict.cpp -> storage/ndb/test/ndbapi/testDict.cpp
storage/ndb/test/run-test/daily-basic-tests.txt@stripped, 2006-07-24 02:30:05+10:00, stewart@willster.(none) +0 -0
Auto merged
MERGE: 1.27.13.2
storage/ndb/test/run-test/daily-basic-tests.txt@stripped, 2006-07-24 02:30:05+10:00, stewart@willster.(none) +0 -0
Merge rename: ndb/test/run-test/daily-basic-tests.txt -> storage/ndb/test/run-test/daily-basic-tests.txt
# This is a BitKeeper patch. What follows are the unified diffs for the
# set of deltas contained in the patch. The rest of the patch, the part
# that BitKeeper cares about, is below these diffs.
# User: stewart
# Host: willster.(none)
# Root: /home/stewart/Documents/MySQL/5.1/main/RESYNC
--- 1.27.13.1/ndb/test/run-test/daily-basic-tests.txt 2006-07-24 02:32:54 +10:00
+++ 1.50/storage/ndb/test/run-test/daily-basic-tests.txt 2006-07-24 02:32:54 +10:00
@@ -81,23 +81,23 @@
max-time: 500
cmd: testBasic
-args: -n PkReadAndLocker T6
+args: -n PkReadAndLocker T6 D1 D2
max-time: 500
cmd: testBasic
-args: -n PkReadAndLocker2 T6
+args: -n PkReadAndLocker2 T6 D1 D2
max-time: 500
cmd: testBasic
-args: -n PkReadUpdateAndLocker T6
+args: -n PkReadUpdateAndLocker T6 D1 D2
max-time: 500
cmd: testBasic
-args: -n ReadWithLocksAndInserts T6
+args: -n ReadWithLocksAndInserts T6 D1 D2
max-time: 500
cmd: testBasic
-args: -n PkInsertTwice T1 T6 T10
+args: -n PkInsertTwice T1 T6 T10 D1 D2
max-time: 1500
cmd: testBasic
@@ -109,79 +109,79 @@
max-time: 500
cmd: testBasic
-args: -n NoCommitSleep T6
+args: -n NoCommitSleep T6 D1 D2
max-time: 500
cmd: testBasic
-args: -n NoCommit626 T6
+args: -n NoCommit626 T6 D1 D2
max-time: 500
cmd: testBasic
-args: -n NoCommitAndClose T6
+args: -n NoCommitAndClose T6 D1 D2
max-time: 500
cmd: testBasic
-args: -n Commit626 T6
+args: -n Commit626 T6 D1 D2
max-time: 500
cmd: testBasic
-args: -n CommitTry626 T6
+args: -n CommitTry626 T6 D1 D2
max-time: 500
cmd: testBasic
-args: -n CommitAsMuch626 T6
+args: -n CommitAsMuch626 T6 D1 D2
max-time: 500
cmd: testBasic
-args: -n NoCommit626 T6
+args: -n NoCommit626 T6 D1 D2
max-time: 500
cmd: testBasic
-args: -n NoCommitRollback626 T1 T6
+args: -n NoCommitRollback626 T1 T6 D1 D2
max-time: 500
cmd: testBasic
-args: -n Commit630 T1 T6
+args: -n Commit630 T1 T6 D1 D2
max-time: 500
cmd: testBasic
-args: -n CommitTry630 T1 T6
+args: -n CommitTry630 T1 T6 D1 D2
max-time: 500
cmd: testBasic
-args: -n CommitAsMuch630 T1 T6
+args: -n CommitAsMuch630 T1 T6 D1 D2
max-time: 500
cmd: testBasic
-args: -n NoCommit630 T1 T6
+args: -n NoCommit630 T1 T6 D1 D2
max-time: 500
cmd: testBasic
-args: -n NoCommitRollback630 T1 T6
+args: -n NoCommitRollback630 T1 T6 D1 D2
max-time: 500
cmd: testBasic
-args: -n NoCommitAndClose T1 T6
+args: -n NoCommitAndClose T1 T6 D1 D2
max-time: 500
cmd: testBasic
-args: -n RollbackUpdate T1 T6
+args: -n RollbackUpdate T1 T6 D1 D2
max-time: 500
cmd: testBasic
-args: -n RollbackDeleteMultiple T1 T6
+args: -n RollbackDeleteMultiple T1 T6 D1 D2
max-time: 500
cmd: testBasic
-args: -n ImplicitRollbackDelete T1 T6
+args: -n ImplicitRollbackDelete T1 T6 D1 D2
max-time: 500
cmd: testBasic
-args: -n CommitDelete T1 T6
+args: -n CommitDelete T1 T6 D1 D2
max-time: 500
cmd: testBasic
-args: -n RollbackNothing T1 T6
+args: -n RollbackNothing T1 T6 D1 D2
max-time: 500
cmd: testBasicAsynch
@@ -199,13 +199,33 @@
cmd: testBasicAsynch
args: -n PkDeleteAsynch
+max-time: 1000
+cmd: testBasic
+args: -n MassiveRollback T1 T7 D1 D2
+
+max-time: 500
+cmd: testBasic
+args: -n MassiveRollback2 T1 T7 D1 D2
+
+max-time: 500
+cmd: testBasic
+args: -n MassiveRollback3 T1 T7 D1 D2
+
+max-time: 500
+cmd: testBasic
+args: -n MassiveRollback4 T1 T7 D1 D2
+
+max-time: 500
+cmd: testBasic
+args: -n TupError
+
max-time: 500
cmd: testBasic
-args: -n MassiveRollback T1 T6 T13
+args: -n InsertError T1
max-time: 500
cmd: testBasic
-args: -n MassiveRollback2 T1 T6 T13
+args: -n InsertError2 T1
max-time: 500
cmd: testTimeout
@@ -231,7 +251,7 @@
max-time: 500
cmd: testScan
-args: -n ScanUpdate2 T6
+args: -n ScanUpdate2 T6 D1 D2
max-time: 500
cmd: testScan
@@ -239,47 +259,51 @@
max-time: 500
cmd: testScan
-args: -n ScanDelete2 T10
+args: -n ScanDelete2 T10 D1 D2
max-time: 500
cmd: testScan
-args: -n ScanUpdateAndScanRead T6
+args: -n ScanUpdateAndScanRead T6 D1 D2
max-time: 500
cmd: testScan
-args: -n ScanReadAndLocker T6
+args: -n ScanReadAndLocker T6 D1 D2
max-time: 500
cmd: testScan
-args: -n ScanReadAndPkRead T6
+args: -n ScanReadAndPkRead T6 D1 D2
max-time: 500
cmd: testScan
-args: -n ScanRead488 -l 10 T6
+args: -n ScanRead488 -l 10 T6 D1 D2
max-time: 500
cmd: testScan
-args: -n ScanRead488O -l 10 T6
+args: -n ScanRead488O -l 10 T6 D1 D2
max-time: 1000
cmd: testScan
-args: -n ScanRead488_Mixed -l 10 T6
+args: -n ScanRead488T -l 10 T6 D1 D2
+
+max-time: 1000
+cmd: testScan
+args: -n ScanRead488_Mixed -l 10 T6 D1 D2
max-time: 500
cmd: testScan
-args: -n ScanRead488Timeout -l 10 T6
+args: -n ScanRead488Timeout -l 10 T6 D1 D2
max-time: 600
cmd: testScan
-args: -n ScanRead40 -l 100 T2
+args: -n ScanRead40 -l 100 T2 D1 D2
max-time: 1800
cmd: testScan
-args: -n ScanRead100 -l 100 T1
+args: -n ScanRead100 -l 100 T1 D1 D2
max-time: 600
cmd: testScan
-args: -n ScanRead40 -l 100 T1
+args: -n ScanRead40 -l 100 T1 D1 D2
max-time: 1800
cmd: testScan
@@ -291,129 +315,145 @@
max-time: 500
cmd: testScan
-args: -n ScanWithLocksAndInserts T6
+args: -n ScanWithLocksAndInserts T6 D1 D2
max-time: 500
cmd: testScan
-args: -n ScanReadAbort T6
+args: -n ScanReadAbort T6 D1 D2
max-time: 500
cmd: testScan
-args: -n ScanReadAbort15 T6
+args: -n ScanReadAbort15 T6 D1 D2
max-time: 500
cmd: testScan
-args: -n ScanReadAbort240 T6
+args: -n ScanReadAbort240 T6 D1 D2
max-time: 500
cmd: testScan
-args: -n ScanUpdateAbort16 T6
+args: -n ScanUpdateAbort16 T6 D1 D2
max-time: 3600
cmd: testScan
-args: -n ScanReadRestart T1 T6 T13
+args: -n ScanReadRestart T1 T6 T13
-max-time: 500
+max-time: 3600
cmd: testScan
-args: -n ScanUpdateRestart T6
+args: -n ScanReadRestart D1 D2
-max-time: 500
+max-time: 1200
+cmd: testScan
+args: -n ScanUpdateRestart T6
+
+max-time: 1200
cmd: testScan
-args: -n CheckGetValue T6
+args: -n ScanUpdateRestart D1 D2
max-time: 500
cmd: testScan
-args: -n CloseWithoutStop T6
+args: -n CheckGetValue T6 D1 D2
max-time: 500
cmd: testScan
-args: -n NextScanWhenNoMore T6
+args: -n CloseWithoutStop T6 D1 D2
max-time: 500
cmd: testScan
-args: -n ExecuteScanWithoutOpenScan T6
+args: -n NextScanWhenNoMore T6 D1 D2
max-time: 500
cmd: testScan
-args: -n OnlyOpenScanOnce T6
+args: -n ExecuteScanWithoutOpenScan T6 D1 D2
max-time: 500
cmd: testScan
-args: -n OnlyOneOpInScanTrans T6
+args: -n OnlyOpenScanOnce T6 D1 D2
max-time: 500
cmd: testScan
-args: -n OnlyOneOpBeforeOpenScan T6
+args: -n OnlyOneOpInScanTrans T6 D1 D2
max-time: 500
cmd: testScan
-args: -n OnlyOneScanPerTrans T6
+args: -n OnlyOneOpBeforeOpenScan T6 D1 D2
max-time: 500
cmd: testScan
-args: -n NoCloseTransaction T6
+args: -n OnlyOneScanPerTrans T6 D1 D2
max-time: 500
cmd: testScan
-args: -n CheckInactivityTimeOut T6
+args: -n NoCloseTransaction T6 D1 D2
max-time: 500
cmd: testScan
-args: -n CheckInactivityBeforeClose T6
+args: -n CheckInactivityTimeOut T6 D1 D2
max-time: 500
cmd: testScan
-args: -n CheckAfterTerror T6
+args: -n CheckInactivityBeforeClose T6 D1 D2
max-time: 500
cmd: testScan
-args: -n ScanReadError5021 T1
+args: -n CheckAfterTerror T6 D1 D2
max-time: 500
cmd: testScan
-args: -n ScanReaderror5022 T1
+args: -n ScanReadError5021 T1 D1 D2
max-time: 500
cmd: testScan
-args: -n ScanReadError5023 T1
+args: -n ScanReaderror5022 T1 D1 D2
max-time: 500
cmd: testScan
-args: -n ScanReadError5024 T1
+args: -n ScanReadError5023 T1 D1 D2
max-time: 500
cmd: testScan
-args: -n ScanReadError5025 T1
+args: -n ScanReadError5024 T1 D1 D2
max-time: 500
cmd: testScan
-args: -n ScanReadError5030 T1
+args: -n ScanReadError5025 T1 D1 D2
max-time: 500
cmd: testScan
-args: -n InsertDelete T1 T6
+args: -n ScanReadError5030 T1 D1 D2
max-time: 500
cmd: testScan
-args: -n CheckAfterTerror T1
+args: -n InsertDelete T1 T6 D1 D2
max-time: 500
cmd: testScan
+args: -n CheckAfterTerror T1 D1 D2
+
+max-time: 1200
+cmd: testScan
args: -n ScanReadWhileNodeIsDown T1
+max-time: 1200
+cmd: testScan
+args: -n ScanReadWhileNodeIsDown D1 D2
+
max-time: 500
cmd: testScan
-args: -n ScanRestart T1
+args: -n ScanRestart T1 D1 D2
max-time: 500
cmd: testScan
-args: -l 100 -n Scan-bug8262 T7
+args: -l 100 -n Scan-bug8262 T7 D1 D2
max-time: 500
cmd: testScan
args: -n ScanParallelism
max-time: 500
+cmd: testScan
+args: -n ScanVariants
+
+max-time: 500
cmd: testNodeRestart
args: -n Bug15587 T1
@@ -449,15 +489,6 @@
cmd: testNodeRestart
args: -n Bug20185 T1
-# OLD FLEX
-max-time: 500
-cmd: flexBench
-args: -c 25 -t 10
-
-max-time: 500
-cmd: flexHammer
-args: -r 5 -t 32
-
#
# DICT TESTS
max-time: 1500
@@ -474,7 +505,7 @@
max-time: 1500
cmd: testDict
-args: -n CreateAndDropDuring T6 T10
+args: -n CreateAndDropDuring T6 T10 D1 D2
max-time: 1500
cmd: testDict
@@ -504,6 +535,10 @@
cmd: testDict
args: -n TemporaryTables T1 T6 T7 T8
+max-time: 1500
+cmd: testDict
+args: -n Restart_NR2 T1
+
#
# TEST NDBAPI
#
@@ -559,23 +594,27 @@
max-time: 500
cmd: testNdbApi
-args: -n UpdateWithoutKeys T6
+args: -n UpdateWithoutKeys T6 D1 D2
max-time: 500
cmd: testNdbApi
-args: -n UpdateWithoutValues T6
+args: -n UpdateWithoutValues T6 D1 D2
max-time: 500
cmd: testNdbApi
-args: -n ReadWithoutGetValue
+args: -n ReadWithoutGetValue D1 D2
max-time: 500
cmd: testNdbApi
-args: -n Bug_11133 T1
+args: -n Bug_11133 T1 D1 D2
max-time: 500
cmd: testNdbApi
-args: -n Scan_4006 T1
+args: -n Scan_4006 T1 D1 D2
+
+max-time: 500
+cmd: testNdbApi
+args: -n Bug_WritePartialIgnoreError T1
#max-time: 500
#cmd: testInterpreter
@@ -593,7 +632,7 @@
cmd: testRestartGci
args: T6
-max-time: 600
+max-time: 1500
cmd: testBlobs
args:
@@ -631,6 +670,14 @@
max-time: 1500
cmd: testSystemRestart
+args: -n SR1 D1
+
+max-time: 1500
+cmd: testSystemRestart
+args: -n SR1 D2
+
+max-time: 1500
+cmd: testSystemRestart
args: -n SR2 T1
max-time: 1500
@@ -643,6 +690,14 @@
max-time: 1500
cmd: testSystemRestart
+args: -n SR2 D1
+
+max-time: 1500
+cmd: testSystemRestart
+args: -n SR2 D2
+
+max-time: 1500
+cmd: testSystemRestart
args: -n SR_UNDO T1
max-time: 1500
@@ -656,6 +711,18 @@
max-time: 1500
cmd: testSystemRestart
args: -n SR_UNDO T8
+
+max-time: 1000
+cmd: testSRBank
+args: -n SR -l 300 -r 15 T1
+
+max-time: 1000
+cmd: testSRBank
+args: -n NR -l 300 -r 15 T1
+
+max-time: 1000
+cmd: testSRBank
+args: -n Mix -l 300 -r 15 T1
# OLD FLEX
max-time: 500
--- 1.9.11.1/ndb/src/kernel/blocks/ERROR_codes.txt 2006-07-24 02:32:54 +10:00
+++ 1.23/storage/ndb/src/kernel/blocks/ERROR_codes.txt 2006-07-24 02:32:54 +10:00
@@ -476,3 +476,13 @@
6003 Crash in participant @ CreateTabReq::Prepare
6004 Crash in participant @ CreateTabReq::Commit
6005 Crash in participant @ CreateTabReq::CreateDrop
+
+Dbtup:
+4014 - handleInsert - Out of undo buffer
+4015 - handleInsert - Out of log space
+4016 - handleInsert - AI Inconsistency
+4017 - handleInsert - Out of memory
+4018 - handleInsert - Null check error
+4019 - handleInsert - Alloc rowid error
+4020 - handleInsert - Size change error
+4021 - handleInsert - Out of disk space
--- 1.22.4.1/ndb/src/kernel/blocks/dbtup/Dbtup.hpp 2006-07-24 02:32:54 +10:00
+++ 1.48/storage/ndb/src/kernel/blocks/dbtup/Dbtup.hpp 2006-07-24 02:32:54 +10:00
@@ -21,7 +21,6 @@
#include <SimulatedBlock.hpp>
#include <ndb_limits.h>
#include <trigger_definitions.h>
-#include <ArrayList.hpp>
#include <AttributeHeader.hpp>
#include <Bitmask.hpp>
#include <signaldata/TupKey.hpp>
@@ -29,11 +28,36 @@
#include <signaldata/DropTrig.hpp>
#include <signaldata/TrigAttrInfo.hpp>
#include <signaldata/BuildIndx.hpp>
+#include "Undo_buffer.hpp"
+#include "tuppage.hpp"
+#include <../pgman.hpp>
+#include <../tsman.hpp>
+
+#ifdef VM_TRACE
+inline const char* dbgmask(const Bitmask<MAXNROFATTRIBUTESINWORDS>& bm) {
+ static int i=0; static char buf[5][200];
+ bm.getText(buf[i%5]); return buf[i++%5]; }
+inline const char* dbgmask(const Uint32 bm[2]) {
+ static int i=0; static char buf[5][200];
+ sprintf(buf[i%5],"%08x%08x",bm[1],bm[0]); return buf[i++%5]; }
+#endif
#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
+#define ZTUP_VERSION_MASK ((1 << ZTUP_VERSION_BITS) - 1)
+#define MAX_FREE_LIST 4
+
+inline Uint32* ALIGN_WORD(void * ptr)
+{
+ return (Uint32*)(((UintPtr(ptr) + 3) >> 2) << 2);
+}
+
+inline const Uint32* ALIGN_WORD(const void* ptr)
+{
+ return (Uint32*)(((UintPtr(ptr) + 3) >> 2) << 2);
+}
#ifdef DBTUP_C
//------------------------------------------------------------------
@@ -53,18 +77,16 @@
// 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
-// DbtupScan.cpp 32000
+// DbtupVarAlloc.cpp 32000
+// DbtupScan.cpp 33000
//------------------------------------------------------------------
/*
@@ -78,37 +100,13 @@
#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_LCP_REC 10 /* NUMBER OF CONCURRENT CHECKPOINTS*/
#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 */
- /* 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 */
@@ -117,12 +115,11 @@
/**
* #defines moved into include/kernel/Interpreter.hpp
*/
-#define ZMAX_REGISTER 21
#define ZINSERT_DELETE 0
+#define ZUPDATE_ALL 8
/* ---------------------------------------------------------------- */
/* 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 */
@@ -134,31 +131,10 @@
/* 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 */
@@ -209,40 +185,15 @@
#define ZINSERT_ERROR 630
#define ZINVALID_CHAR_FORMAT 744
-
+#define ZROWID_ALLOCATED 899
/* 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 */
@@ -285,142 +236,83 @@
#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 ZTUP_SCAN 10
+#define ZFREE_EXTENT 11
+#define ZUNMAP_PAGES 12
+#define ZFREE_VAR_PAGES 13
-#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 {
+friend class Suma;
public:
-
- typedef bool (Dbtup::* ReadFunction)(Uint32*,
- AttributeHeader*,
- Uint32,
+struct KeyReqStruct;
+friend struct KeyReqStruct; // CC
+typedef bool (Dbtup::* ReadFunction)(Uint32*,
+ KeyReqStruct*,
+ AttributeHeader*,
+ Uint32);
+typedef bool (Dbtup::* UpdateFunction)(Uint32*,
+ KeyReqStruct*,
Uint32);
- typedef bool (Dbtup::* UpdateFunction)(Uint32*,
- Uint32,
- Uint32);
+private:
+
+ typedef Tup_fixsize_page Fix_page;
+ typedef Tup_varsize_page Var_page;
+
+public:
+ class Dblqh *c_lqh;
+ Tsman* c_tsman;
+ Lgman* c_lgman;
+ Page_cache_client m_pgman;
+
// State values
+enum ChangeMaskState {
+ DELETE_CHANGES = 0,
+ SET_ALL_MASK = 1,
+ USE_SAVED_CHANGE_MASK = 2,
+ RECALCULATE_CHANGE_MASK = 3
+};
+
+enum TransState {
+ TRANS_IDLE = 0,
+ TRANS_STARTED = 1,
+ TRANS_WAIT_STORED_PROCEDURE_ATTR_INFO = 2,
+ TRANS_ERROR_WAIT_STORED_PROCREQ = 3,
+ TRANS_ERROR_WAIT_TUPKEYREQ = 4,
+ TRANS_TOO_MUCH_AI = 5,
+ TRANS_DISCONNECTED = 6
+};
+
+enum TupleState {
+ TUPLE_PREPARED = 1,
+ TUPLE_ALREADY_ABORTED = 2,
+ TUPLE_TO_BE_COMMITTED = 3
+};
+
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
+ DROPPING = 68
};
// Records
@@ -433,67 +325,7 @@
typedef Ptr<Attrbufrec> 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<CheckpointInfo> 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<DiskBufferSegmentInfo> DiskBufferSegmentInfoPtr;
struct Fragoperrec {
Uint64 minRows;
@@ -504,45 +336,116 @@
Uint32 tableidFrag;
Uint32 fragPointer;
Uint32 attributeCount;
- Uint32 currNullBit;
- Uint32 noOfNullBits;
- Uint32 noOfNewAttrCount;
Uint32 charsetIndex;
+ Uint32 m_null_bits[2];
+ Uint32 m_fix_attributes_size[2]; // In words
+ Uint32 m_var_attributes_size[2]; // In bytes
BlockReference lqhBlockrefFrag;
bool inUse;
bool definingFragment;
};
typedef Ptr<Fragoperrec> FragoperrecPtr;
- // Position for use by scan
- struct PagePos {
- Uint32 m_fragId; // "base" fragment id
- Uint32 m_fragBit; // two fragments in 5.0
- Uint32 m_pageId;
- Uint32 m_tupleNo;
- bool m_match;
+
+ typedef Tup_page Page;
+ typedef Ptr<Page> PagePtr;
+
+ // Scan position
+ struct ScanPos {
+ enum Get {
+ Get_undef = 0,
+ Get_next_page,
+ Get_page,
+ Get_next_page_mm,
+ Get_page_mm,
+ Get_next_page_dd,
+ Get_page_dd,
+ Get_next_tuple,
+ Get_tuple,
+ Get_next_tuple_fs,
+ Get_tuple_fs
+ };
+ Get m_get; // entry point in scanNext
+ Local_key m_key; // scan position pointer MM or DD
+ Page* m_page; // scanned MM or DD (cache) page
+ Local_key m_key_mm; // MM local key returned
+ Uint32 m_realpid_mm; // MM real page id
+ Uint32 m_extent_info_ptr_i;
};
- // Tup scan op (compare Dbtux::ScanOp)
+ // Scan Lock
+ struct ScanLock {
+ Uint32 m_accLockOp;
+ union {
+ Uint32 nextPool;
+ Uint32 nextList;
+ };
+ Uint32 prevList;
+ };
+ typedef Ptr<ScanLock> ScanLockPtr;
+ ArrayPool<ScanLock> c_scanLockPool;
+
+ // Tup scan, similar to Tux scan. Later some of this could
+ // be moved to common superclass.
struct ScanOp {
- enum {
+ ScanOp() :
+ m_state(Undef),
+ m_bits(0),
+ m_userPtr(RNIL),
+ m_userRef(RNIL),
+ m_tableId(RNIL),
+ m_fragId(~(Uint32)0),
+ m_fragPtrI(RNIL),
+ m_transId1(0),
+ m_transId2(0),
+ m_savePointId(0),
+ m_accLockOp(RNIL)
+ {}
+
+ enum State {
Undef = 0,
First = 1, // before first entry
- Locked = 4, // at current entry (no lock needed)
+ 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; // unused
+
+ enum Bits {
+ SCAN_DD = 0x01, // scan disk pages
+ SCAN_VS = 0x02, // page format is var size
+ SCAN_LCP = 0x04, // LCP mem page scan
+ SCAN_LOCK_SH = 0x10, // lock mode shared
+ SCAN_LOCK_EX = 0x20, // lock mode exclusive
+ SCAN_LOCK_WAIT = 0x40, // lock wait
+ // any lock mode
+ SCAN_LOCK = SCAN_LOCK_SH | SCAN_LOCK_EX,
+ SCAN_NR = 0x80 // Node recovery scan
+ };
+ Uint16 m_bits;
+
Uint32 m_userPtr; // scanptr.i in LQH
Uint32 m_userRef;
Uint32 m_tableId;
- Uint32 m_fragId; // "base" fragment id
- Uint32 m_fragPtrI[2];
+ Uint32 m_fragId;
+ Uint32 m_fragPtrI;
Uint32 m_transId1;
Uint32 m_transId2;
- PagePos m_scanPos;
+ union {
+ Uint32 m_savePointId;
+ Uint32 m_scanGCI;
+ };
+ // lock waited for or obtained and not yet passed to LQH
+ Uint32 m_accLockOp;
+
+ ScanPos m_scanPos;
+
+ DLFifoList<ScanLock>::Head m_accLockOps;
+
union {
Uint32 nextPool;
Uint32 nextList;
@@ -552,135 +455,303 @@
typedef Ptr<ScanOp> ScanOpPtr;
ArrayPool<ScanOp> c_scanOpPool;
- void scanFirst(Signal* signal, ScanOpPtr scanPtr);
- void scanNext(Signal* signal, ScanOpPtr scanPtr);
- void scanClose(Signal* signal, ScanOpPtr scanPtr);
+ void scanReply(Signal*, ScanOpPtr scanPtr);
+ void scanFirst(Signal*, ScanOpPtr scanPtr);
+ bool scanNext(Signal*, ScanOpPtr scanPtr);
+ void scanCont(Signal*, ScanOpPtr scanPtr);
+ void disk_page_tup_scan_callback(Signal*, Uint32 scanPtrI, Uint32 page_i);
+ void scanClose(Signal*, ScanOpPtr scanPtr);
+ void addAccLockOp(ScanOp& scan, Uint32 accLockOp);
+ void removeAccLockOp(ScanOp& scan, Uint32 accLockOp);
void releaseScanOp(ScanOpPtr& scanPtr);
+ // for md5 of key (could maybe reuse existing temp buffer)
+ Uint64 c_dataBuffer[ZWORDS_ON_PAGE/2 + 1];
+
+ struct Page_request
+ {
+ Local_key m_key;
+ Uint32 m_frag_ptr_i;
+ Uint32 m_extent_info_ptr;
+ Uint16 m_estimated_free_space; // in bytes/records
+ Uint16 m_list_index; // in Disk_alloc_info.m_page_requests
+ Uint16 m_ref_count; // Waiters for page
+ Uint16 m_uncommitted_used_space;
+ Uint32 nextList;
+ Uint32 prevList;
+ Uint32 m_magic;
+ }; // 32 bytes
+
+ typedef RecordPool<Page_request, WOPool> Page_request_pool;
+ typedef DLFifoListImpl<Page_request_pool, Page_request> Page_request_list;
+ typedef LocalDLFifoListImpl<Page_request_pool, Page_request> Local_page_request_list;
+
+ STATIC_CONST( EXTENT_SEARCH_MATRIX_COLS = 4 ); // Guarantee size
+ STATIC_CONST( EXTENT_SEARCH_MATRIX_ROWS = 5 ); // Total size
+ STATIC_CONST( EXTENT_SEARCH_MATRIX_SIZE = 20 );
+
+ struct Extent_list_t
+ {
+ Uint32 nextList;
+ };
+
+ struct Extent_info : public Extent_list_t
+ {
+ Uint32 m_magic;
+ Uint32 m_first_page_no;
+ Local_key m_key;
+ Uint32 m_free_space;
+ Uint32 m_free_matrix_pos;
+ Uint16 m_free_page_count[EXTENT_SEARCH_MATRIX_COLS];
+ union {
+ Uint32 nextList;
+ Uint32 nextPool;
+ };
+ Uint32 prevList;
+ Uint32 nextHash, prevHash;
+
+ Uint32 hashValue() const {
+ return (m_key.m_file_no << 16) ^ m_key.m_page_idx;
+ }
+
+ bool equal(const Extent_info & rec) const {
+ return m_key.m_file_no == rec.m_key.m_file_no &&
+ m_key.m_page_idx == rec.m_key.m_page_idx;
+ }
+ }; // 40 bytes
+
+ typedef RecordPool<Extent_info, RWPool> Extent_info_pool;
+ typedef DLListImpl<Extent_info_pool, Extent_info> Extent_info_list;
+ typedef LocalDLListImpl<Extent_info_pool, Extent_info> Local_extent_info_list;
+ typedef DLHashTableImpl<Extent_info_pool, Extent_info> Extent_info_hash;
+ typedef SLListImpl<Extent_info_pool, Extent_info, Extent_list_t> Fragment_extent_list;
+ typedef LocalSLListImpl<Extent_info_pool, Extent_info, Extent_list_t> Local_fragment_extent_list;
+ struct Tablerec;
+ struct Disk_alloc_info
+ {
+ Disk_alloc_info() {}
+ Disk_alloc_info(const Tablerec* tabPtrP,
+ Uint32 extent_size_in_pages);
+ Uint32 m_extent_size;
+
+ /**
+ * Disk allocation
+ *
+ * 1) Allocate space on pages that already are dirty
+ * (4 free lists for different requests)
+ * 2) Allocate space on pages waiting to maped that will be dirty
+ * (4 free lists for different requests)
+ * 3) Check if "current" extent can accommodate request
+ * If so, allocate page from there
+ * Else put "current" into free matrix
+ * 4) Search free matrix for extent with greatest amount of free space
+ * while still accommodating current request
+ * (20 free lists for different requests)
+ */
+
+ /**
+ * Free list of pages in different size
+ * that are dirty
+ */
+ DLList<Page>::Head m_dirty_pages[MAX_FREE_LIST]; // In real page id's
+
+ /**
+ * Requests (for update) that have sufficient space left after request
+ * these are currently being "mapped"
+ */
+ Page_request_list::Head m_page_requests[MAX_FREE_LIST];
+
+ /**
+ * Current extent
+ */
+ Uint32 m_curr_extent_info_ptr_i;
+
+ /**
+ *
+ */
+ STATIC_CONST( SZ = EXTENT_SEARCH_MATRIX_SIZE );
+ Extent_info_list::Head m_free_extents[SZ];
+ Uint32 m_total_extent_free_space_thresholds[EXTENT_SEARCH_MATRIX_ROWS];
+ Uint32 m_page_free_bits_map[EXTENT_SEARCH_MATRIX_COLS];
+
+ Uint32 find_extent(Uint32 sz) const;
+ Uint32 calc_extent_pos(const Extent_info*) const;
+
+ /**
+ * Compute minimum free space on page given bits
+ */
+ Uint32 calc_page_free_space(Uint32 bits) const {
+ return m_page_free_bits_map[bits];
+ }
+
+ /**
+ * Compute page free bits, given free space
+ */
+ Uint32 calc_page_free_bits(Uint32 free) const {
+ for(Uint32 i = 0; i<EXTENT_SEARCH_MATRIX_COLS-1; i++)
+ if(free >= m_page_free_bits_map[i])
+ return i;
+ return EXTENT_SEARCH_MATRIX_COLS - 1;
+ }
+
+ Fragment_extent_list::Head m_extent_list;
+ };
+
+ void dump_disk_alloc(Disk_alloc_info&);
+
struct Fragrecord {
Uint32 nextStartRange;
Uint32 currentPageRange;
Uint32 rootPageRange;
Uint32 noOfPages;
+ Uint32 noOfVarPages;
Uint32 noOfPagesToGrow;
- Uint32 emptyPrimPage;
- Uint32 firstusedOprec;
- Uint32 lastusedOprec;
+ DLList<Page>::Head emptyPrimPage; // allocated pages (not init)
+ DLList<Page>::Head thFreeFirst; // pages with atleast 1 free record
+ SLList<Page>::Head m_empty_pages; // Empty pages not in logical/physical map
+
+ Uint32 m_lcp_scan_op;
+ Uint32 m_lcp_keep_list;
- Uint32 thFreeFirst;
- Uint32 thFreeCopyFirst;
- Uint32 noCopyPagesAlloc;
-
- Uint32 checkpointVersion;
- Uint32 minPageNotWrittenInCheckpoint;
- Uint32 maxPageWrittenInCheckpoint;
State fragStatus;
Uint32 fragTableId;
Uint32 fragmentId;
Uint32 nextfreefrag;
+ DLList<Page>::Head free_var_page_array[MAX_FREE_LIST];
+
+ DLList<ScanOp>::Head m_scanList;
- DLList<ScanOp> m_scanList;
- Fragrecord(ArrayPool<ScanOp> & scanOpPool) : m_scanList(scanOpPool) {}
+ bool m_undo_complete;
+ Uint32 m_tablespace_id;
+ Uint32 m_logfile_group_id;
+ Disk_alloc_info m_disk_alloc_info;
+ Uint32 m_var_page_chunks;
};
typedef Ptr<Fragrecord> 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<LocalLogInfo> 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;
+ /*
+ * To handle Attrinfo signals and buffer them up we need to
+ * a simple list with first and last and we also need to keep track
+ * of how much we received for security check.
+ * Will most likely disappear with introduction of long signals.
+ * These variables are used before TUPKEYREQ is received and not
+ * thereafter and is disposed with after calling copyAttrinfo
+ * which is called before putting the operation into its lists.
+ * Thus we can use union declarations for these variables.
+ */
+
+ /*
+ * Used by scans to find the Attrinfo buffers.
+ * This is only until returning from copyAttrinfo and
+ * can thus reuse the same memory as needed by the
+ * active operation list variables.
+ */
+
+ /*
+ * Doubly linked list with anchor on tuple.
+ * This is to handle multiple updates on the same tuple
+ * by the same transaction.
+ */
+ union {
+ Uint32 prevActiveOp;
+ Uint32 storedProcedureId; //Used until copyAttrinfo
+ };
+ union {
+ Uint32 nextActiveOp;
+ Uint32 currentAttrinbufLen; //Used until copyAttrinfo
+ };
+
+ bool is_first_operation() const { return prevActiveOp == RNIL;}
+ bool is_last_operation() const { return nextActiveOp == RNIL;}
+
+ Uint32 m_undo_buffer_space; // In words
+ union {
+ Uint32 firstAttrinbufrec; //Used until copyAttrinfo
+ };
+ union {
+ Uint32 lastAttrinbufrec; //Used until copyAttrinfo
+ Uint32 nextPool;
+ };
+ Uint32 attrinbufLen; //only used during STORED_PROCDEF phase
+ Uint32 storedProcPtr; //only used during STORED_PROCDEF phase
+
+ /*
+ * From fragment i-value we can find fragment and table record
+ */
Uint32 fragmentPtr;
- Uint32 fragPageId;
- Uint32 realPageId;
- bool undoLogged;
- Uint32 realPageIdC;
- Uint32 fragPageIdC;
- Uint32 firstAttrinbufrec;
- Uint32 lastAttrinbufrec;
- Uint32 attrinbufLen;
- Uint32 currentAttrinbufLen;
+
+ /*
+ * We need references to both the original tuple and the copy tuple.
+ * We keep the page's real i-value and its index and from there we
+ * can find out about the fragment page id and the page offset.
+ */
+ Local_key m_tuple_location;
+ Local_key m_copy_tuple_location;
+
+ /*
+ * We keep the record linked to the operation record in LQH.
+ * This is needed due to writing of REDO log must be performed
+ * in correct order, which is the same order as the writes
+ * occurred. LQH can receive the records in different order.
+ */
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;
+ /*
+ * When responding to queries in the same transaction they will see
+ * a result from the save point id the query was started. Again
+ * functionality for multi-updates of the same record in one
+ * transaction.
+ */
+ union {
+ Uint32 savepointId;
+ Uint32 m_commit_disk_callback_page;
+ };
-// 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;
+ /*
+ * We use 64 bits to save change mask for the most common cases.
+ */
+ Uint32 saved_change_mask[2];
+
+ /*
+ * State variables on connection.
+ * State variable on tuple after multi-updates
+ * Is operation undo logged or not
+ * Is operation in fragment list
+ * Is operation in multi-update list
+ * Operation type (READ, UPDATE, etc)
+ * Is record primary replica
+ * Is delete or insert performed
+ */
+ struct OpBitFields {
+ unsigned int trans_state : 3;
+ unsigned int tuple_state : 2;
+ unsigned int in_active_list : 1;
+
+ unsigned int op_type : 3;
+ unsigned int delete_insert_flag : 1;
+ unsigned int primary_replica : 1;
+ unsigned int change_mask_state : 2;
+ unsigned int m_disk_preallocated : 1;
+ unsigned int m_load_diskpage_on_commit : 1;
+ unsigned int m_wait_log_buffer : 1;
+ };
union {
- Uint32 hashValue; // only used in TUP_COMMITREQ
- Uint32 lastRow;
+ OpBitFields op_struct;
+ Uint16 op_bit_fields;
};
- Bitmask<MAXNROFATTRIBUTESINWORDS> changeMask;
-};
-typedef Ptr<Operationrec> OperationrecPtr;
-struct Page {
- Uint32 pageWord[ZWORDS_ON_PAGE];
+ /*
+ * TUX needs to know the tuple version of the tuple since it
+ * keeps an entry for both the committed and all versions in
+ * a transaction currently. So each update will create a new
+ * version even if in the same transaction.
+ */
+ Uint16 tupVersion;
};
-typedef Ptr<Page> PagePtr;
+typedef Ptr<Operationrec> OperationrecPtr;
/* ****************************** PAGE RANGE RECORD ************************** */
/* PAGE RANGES AND BASE PAGE ID. EACH RANGE HAS A CORRESPONDING BASE PAGE ID */
@@ -704,39 +775,6 @@
};
typedef Ptr<PageRange> 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<PendingFileOpenInfo> 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<RestartInfoRecord> RestartInfoRecordPtr;
/* ************* TRIGGER DATA ************* */
/* THIS RECORD FORMS LISTS OF ACTIVE */
@@ -750,6 +788,10 @@
/**
* Trigger id, used by DICT/TRIX to identify the trigger
+ *
+ * trigger Ids are unique per block for SUBSCRIPTION triggers.
+ * This is so that BACKUP can use TUP triggers directly and delete them
+ * properly.
*/
Uint32 triggerId;
@@ -820,80 +862,177 @@
*/
ArrayPool<TupTriggerData> c_triggerPool;
- /* ************ TABLE RECORD ************ */
- /* THIS RECORD FORMS A LIST OF TABLE */
- /* REFERENCE INFORMATION. ONE RECORD */
- /* PER TABLE REFERENCE. */
- /* ************************************** */
-struct Tablerec {
- Tablerec(ArrayPool<TupTriggerData> & triggerPool) :
- afterInsertTriggers(triggerPool),
- afterDeleteTriggers(triggerPool),
- afterUpdateTriggers(triggerPool),
- subscriptionInsertTriggers(triggerPool),
- subscriptionDeleteTriggers(triggerPool),
- subscriptionUpdateTriggers(triggerPool),
- constraintUpdateTriggers(triggerPool),
- tuxCustomTriggers(triggerPool)
- {}
-
- Bitmask<MAXNROFATTRIBUTESINWORDS> notNullAttributeMask;
-
- ReadFunction* readFunctionArray;
- UpdateFunction* updateFunctionArray;
- CHARSET_INFO** charsetArray;
-
- Uint32 readKeyArray;
- Uint32 tabDescriptor;
- Uint32 attributeGroupDescriptor;
-
- bool GCPIndicator;
- bool checksumIndicator;
-
- Uint16 tupheadsize;
- Uint16 noOfAttr;
- Uint16 noOfKeyAttr;
- Uint16 noOfCharsets;
- Uint16 noOfNewAttr;
- Uint16 noOfNullAttr;
- Uint16 noOfAttributeGroups;
-
- Uint8 tupChecksumIndex;
- Uint8 tupNullIndex;
- Uint8 tupNullWords;
- Uint8 tupGCPIndex;
-
- // Lists of trigger data for active triggers
- ArrayList<TupTriggerData> afterInsertTriggers;
- ArrayList<TupTriggerData> afterDeleteTriggers;
- ArrayList<TupTriggerData> afterUpdateTriggers;
- ArrayList<TupTriggerData> subscriptionInsertTriggers;
- ArrayList<TupTriggerData> subscriptionDeleteTriggers;
- ArrayList<TupTriggerData> subscriptionUpdateTriggers;
- ArrayList<TupTriggerData> constraintUpdateTriggers;
-
- // List of ordered indexes
- ArrayList<TupTriggerData> tuxCustomTriggers;
-
- Uint32 fragid[2 * MAX_FRAG_PER_NODE];
- Uint32 fragrec[2 * MAX_FRAG_PER_NODE];
-
- struct {
- Uint32 tabUserPtr;
- Uint32 tabUserRef;
- } m_dropTable;
- State tableStatus;
-};
-
-typedef Ptr<Tablerec> TablerecPtr;
-
-struct storedProc {
- Uint32 storedLinkFirst;
- Uint32 storedLinkLast;
- Uint32 storedCounter;
- Uint32 nextPool;
- Uint16 storedCode;
- Uint16 storedProcLength;
+ /* ************ TABLE RECORD ************ */
+ /* THIS RECORD FORMS A LIST OF TABLE */
+ /* REFERENCE INFORMATION. ONE RECORD */
+ /* PER TABLE REFERENCE. */
+ /* ************************************** */
+ STATIC_CONST( MM = 0 );
+ STATIC_CONST( DD = 1 );
+
+ struct Tablerec {
+ Tablerec(ArrayPool<TupTriggerData> & triggerPool) :
+ afterInsertTriggers(triggerPool),
+ afterDeleteTriggers(triggerPool),
+ afterUpdateTriggers(triggerPool),
+ subscriptionInsertTriggers(triggerPool),
+ subscriptionDeleteTriggers(triggerPool),
+ subscriptionUpdateTriggers(triggerPool),
+ constraintUpdateTriggers(triggerPool),
+ tuxCustomTriggers(triggerPool)
+ {}
+
+ Bitmask<MAXNROFATTRIBUTESINWORDS> notNullAttributeMask;
+ Bitmask<MAXNROFATTRIBUTESINWORDS> blobAttributeMask;
+
+ ReadFunction* readFunctionArray;
+ UpdateFunction* updateFunctionArray;
+ CHARSET_INFO** charsetArray;
+
+ Uint32 readKeyArray;
+ Uint32 tabDescriptor;
+ Uint32 m_real_order_descriptor;
+
+ enum Bits
+ {
+ TR_Checksum = 0x1, // Need to be 1
+ TR_RowGCI = 0x2
+ };
+ Uint16 m_bits;
+ Uint16 total_rec_size; // Max total size for entire tuple in words
+
+ /**
+ * Aggregates
+ */
+ Uint16 m_no_of_attributes;
+ Uint16 m_no_of_disk_attributes;
+ Uint16 noOfKeyAttr;
+ Uint16 noOfCharsets;
+
+ bool need_expand() const {
+ return m_no_of_attributes > m_attributes[MM].m_no_of_fixsize;
+ }
+
+ bool need_expand(bool disk) const {
+ return m_attributes[MM].m_no_of_varsize > 0 ||
+ (disk && m_no_of_disk_attributes > 0);
+ }
+
+ bool need_shrink() const {
+ return
+ m_attributes[MM].m_no_of_varsize > 0 ||
+ m_attributes[DD].m_no_of_varsize > 0;
+ }
+
+ bool need_shrink(bool disk) const {
+ return
+ m_attributes[MM].m_no_of_varsize > 0 ||
+ (disk && m_attributes[DD].m_no_of_varsize > 0);
+ }
+
+ /**
+ * Descriptors for MM and DD part
+ */
+ struct Tuple_offsets {
+ Uint8 m_null_words;
+ Uint8 m_null_offset;
+ Uint16 m_disk_ref_offset; // In words relative m_data
+ union {
+ Uint16 m_varpart_offset; // In words relative m_data
+ Uint16 m_fix_header_size; // For fix size tuples= total rec size(part)
+ };
+ Uint16 m_max_var_offset; // In bytes relative m_var_data.m_data_ptr
+ } m_offsets[2];
+
+
+ Uint32 get_check_offset(Uint32 mm) const {
+ Uint32 cnt= m_attributes[mm].m_no_of_varsize;
+ Uint32 off= m_offsets[mm].m_varpart_offset;
+ return off - (cnt ? 0 : Tuple_header::HeaderSize);
+ }
+
+ struct {
+ Uint16 m_no_of_fixsize;
+ Uint16 m_no_of_varsize;
+ } m_attributes[2];
+
+ // Lists of trigger data for active triggers
+ DLList<TupTriggerData> afterInsertTriggers;
+ DLList<TupTriggerData> afterDeleteTriggers;
+ DLList<TupTriggerData> afterUpdateTriggers;
+ DLList<TupTriggerData> subscriptionInsertTriggers;
+ DLList<TupTriggerData> subscriptionDeleteTriggers;
+ DLList<TupTriggerData> subscriptionUpdateTriggers;
+ DLList<TupTriggerData> constraintUpdateTriggers;
+
+ // List of ordered indexes
+ DLList<TupTriggerData> tuxCustomTriggers;
+
+ Uint32 fragid[MAX_FRAG_PER_NODE];
+ Uint32 fragrec[MAX_FRAG_PER_NODE];
+
+ struct {
+ Uint32 tabUserPtr;
+ Uint32 tabUserRef;
+ } m_dropTable;
+ State tableStatus;
+ };
+
+ struct Disk_undo
+ {
+ enum
+ {
+ UNDO_ALLOC = File_formats::Undofile::UNDO_TUP_ALLOC
+ ,UNDO_UPDATE = File_formats::Undofile::UNDO_TUP_UPDATE
+ ,UNDO_FREE = File_formats::Undofile::UNDO_TUP_FREE
+ ,UNDO_CREATE = File_formats::Undofile::UNDO_TUP_CREATE
+ };
+
+ struct Alloc
+ {
+ Uint32 m_file_no_page_idx; // 16 bit file_no, 16 bit page_idx
+ Uint32 m_page_no;
+ Uint32 m_type_length; // 16 bit type, 16 bit length
+ };
+
+ struct Update
+ {
+ Uint32 m_file_no_page_idx; // 16 bit file_no, 16 bit page_idx
+ Uint32 m_page_no;
+ Uint32 m_gci;
+ Uint32 m_data[1];
+ Uint32 m_type_length; // 16 bit type, 16 bit length
+ };
+
+ struct Free
+ {
+ Uint32 m_file_no_page_idx; // 16 bit file_no, 16 bit page_idx
+ Uint32 m_page_no;
+ Uint32 m_gci;
+ Uint32 m_data[1];
+ Uint32 m_type_length; // 16 bit type, 16 bit length
+ };
+
+ struct Create
+ {
+ Uint32 m_table;
+ Uint32 m_type_length; // 16 bit type, 16 bit length
+ };
+ };
+
+ Extent_info_pool c_extent_pool;
+ Extent_info_hash c_extent_hash;
+ Page_request_pool c_page_request_pool;
+
+ typedef Ptr<Tablerec> TablerecPtr;
+
+ struct storedProc {
+ Uint32 storedLinkFirst;
+ Uint32 storedLinkLast;
+ Uint32 storedCounter;
+ Uint32 nextPool;
+ Uint16 storedCode;
+ Uint16 storedProcLength;
};
typedef Ptr<storedProc> StoredProcPtr;
@@ -1008,27 +1147,18 @@
};
typedef Ptr<HostBuffer> 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<UndoPage> 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
+ Uint8 m_build_vs; // varsize pages
+ Uint32 m_indexId; // the index
Uint32 m_fragNo; // fragment number under Tablerec
Uint32 m_pageId; // logical fragment page id
- Uint32 m_tupleNo; // tuple number on page (pageIndex >> 1)
+ Uint32 m_tupleNo; // tuple number on page
+ Uint32 m_buildRef; // Where to send tuples
BuildIndxRef::ErrorCode m_errorCode;
union {
Uint32 nextPool;
@@ -1038,11 +1168,196 @@
};
typedef Ptr<BuildIndexRec> BuildIndexPtr;
ArrayPool<BuildIndexRec> c_buildIndexPool;
- ArrayList<BuildIndexRec> c_buildIndexList;
+ DLList<BuildIndexRec> c_buildIndexList;
Uint32 c_noOfBuildIndexRec;
+ /**
+ * Reference to variable part when a tuple is chained
+ */
+ struct Var_part_ref
+ {
+ Uint32 m_ref;
+ };
+
+ struct Tuple_header
+ {
+ union {
+ Uint32 m_operation_ptr_i; // OperationPtrI
+ Uint32 m_base_record_ref; // For disk tuple, ref to MM tuple
+ };
+ Uint32 m_header_bits; // Header word
+ union {
+ Uint32 m_checksum;
+ Uint32 m_data[1];
+ Uint32 m_null_bits[1];
+ };
+
+ STATIC_CONST( HeaderSize = 2 );
+
+ /**
+ * header bits
+ */
+ STATIC_CONST( TUP_VERSION_MASK = 0xFFFF );
+ STATIC_CONST( CHAINED_ROW = 0x00010000 ); // Is var part on different page
+ STATIC_CONST( DISK_PART = 0x00020000 ); // Is there a disk part
+ STATIC_CONST( DISK_ALLOC = 0x00040000 ); // Is disk part allocated
+ STATIC_CONST( DISK_INLINE = 0x00080000 ); // Is disk inline
+ STATIC_CONST( ALLOC = 0x00100000 ); // Is record allocated now
+ STATIC_CONST( MM_SHRINK = 0x00200000 ); // Has MM part shrunk
+ STATIC_CONST( MM_GROWN = 0x00400000 ); // Has MM part grown
+ STATIC_CONST( FREED = 0x00800000 ); // Is freed
+ STATIC_CONST( LCP_SKIP = 0x01000000 ); // Should not be returned in LCP
+ STATIC_CONST( LCP_KEEP = 0x02000000 ); // Should be returned in LCP
+ STATIC_CONST( FREE = 0x02800000 ); // Is free
+
+ Uint32 get_tuple_version() const {
+ return m_header_bits & TUP_VERSION_MASK;
+ }
+ void set_tuple_version(Uint32 version) {
+ m_header_bits=
+ (m_header_bits & ~(Uint32)TUP_VERSION_MASK) |
+ (version & TUP_VERSION_MASK);
+ }
+
+ Uint32* get_null_bits(const Tablerec* tabPtrP) {
+ return m_null_bits+tabPtrP->m_offsets[MM].m_null_offset;
+ }
+
+ Uint32* get_null_bits(const Tablerec* tabPtrP, Uint32 mm) {
+ return m_null_bits+tabPtrP->m_offsets[mm].m_null_offset;
+ }
+
+ Uint32* get_var_part_ptr(const Tablerec* tabPtrP) {
+ return m_data + tabPtrP->m_offsets[MM].m_varpart_offset;
+ }
+
+ const Uint32* get_var_part_ptr(const Tablerec* tabPtrP) const {
+ return m_data + tabPtrP->m_offsets[MM].m_varpart_offset;
+ }
+
+ Uint32* get_disk_ref_ptr(const Tablerec* tabPtrP) {
+ return m_data + tabPtrP->m_offsets[MM].m_disk_ref_offset;
+ }
+
+ const Uint32* get_disk_ref_ptr(const Tablerec* tabPtrP) const {
+ return m_data + tabPtrP->m_offsets[MM].m_disk_ref_offset;
+ }
+
+ Uint32 *get_mm_gci(const Tablerec* tabPtrP){
+ assert(tabPtrP->m_bits & Tablerec::TR_RowGCI);
+ return m_data + (tabPtrP->m_bits & Tablerec::TR_Checksum);
+ }
+
+ Uint32 *get_dd_gci(const Tablerec* tabPtrP, Uint32 mm){
+ assert(tabPtrP->m_bits & Tablerec::TR_RowGCI);
+ return m_data;
+ }
+ };
+
+struct KeyReqStruct {
+/**
+ * These variables are used as temporary storage during execution of the
+ * TUPKEYREQ signal.
+ * The first set of variables defines a number of variables needed for
+ * the fix part of the tuple.
+ *
+ * The second part defines a number of commonly used meta data variables.
+ *
+ * The third set of variables defines a set of variables needed for the
+ * variable part.
+ *
+ * The fourth part is variables needed only for updates and inserts.
+ *
+ * The fifth part is a long array of real lengths which is is put last
+ * for cache memory reasons. This is part of the variable part and
+ * contains the real allocated lengths whereas the tuple contains
+ * the length of attribute stored.
+ */
+ Tuple_header *m_tuple_ptr;
+
+ Uint32 check_offset[2];
+
+ TableDescriptor *attr_descr;
+ Uint32 max_read;
+ Uint32 out_buf_index;
+ Uint32 in_buf_index;
+ Uint32 in_buf_len;
+ Uint32 attr_descriptor;
+ bool xfrm_flag;
+
+ struct Var_data {
+ char *m_data_ptr;
+ Uint16 *m_offset_array_ptr;
+ Uint16 m_var_len_offset;
+ Uint16 m_max_var_offset;
+ } m_var_data[2];
+
+ Tuple_header *m_disk_ptr;
+ PagePtr m_page_ptr;
+ PagePtr m_varpart_page_ptr; // could be same as m_page_ptr_p
+ PagePtr m_disk_page_ptr; //
+ Local_key m_row_id;
+
+ bool dirty_op;
+ bool interpreted_exec;
+ bool last_row;
+ bool m_use_rowid;
+
+ Signal* signal;
+ Uint32 no_fired_triggers;
+ Uint32 frag_page_id;
+ Uint32 hash_value;
+ Uint32 gci;
+ Uint32 log_size;
+ Uint32 read_length;
+ Uint32 attrinfo_len;
+ Uint32 tc_operation_ptr;
+ Uint32 trans_id1;
+ Uint32 trans_id2;
+ Uint32 TC_index;
+ // next 2 apply only to attrids >= 64 (zero otherwise)
+ Uint32 max_attr_id_updated;
+ Uint32 no_changed_attrs;
+ BlockReference TC_ref;
+ BlockReference rec_blockref;
+ bool change_mask_calculated;
+ /*
+ * A bit mask where a bit set means that the update or insert
+ * was updating this record.
+ */
+ Bitmask<MAXNROFATTRIBUTESINWORDS> changeMask;
+ Uint16 var_pos_array[2*MAX_ATTRIBUTES_IN_TABLE + 1];
+ OperationrecPtr prevOpPtr;
+};
+
+ friend class Undo_buffer;
+ Undo_buffer c_undo_buffer;
+
+/*
+ No longer used:
+ Implemented by shift instructions in subroutines instead
+
+struct TupHeadInfo {
+ struct BitPart {
+ unsigned int disk_indicator : 1;
+ unsigned int var_part_loc_ind : 1;
+ unsigned int initialised : 1;
+ unsigned int not_used_yet : 5;
+ unsigned int no_var_sized : 8;
+ unsigned int tuple_version : 16;
+ };
+ union {
+ Uint32 all;
+ BitPart bit_part;
+ };
+};
+*/
+
+// updateAttributes module
+ Uint32 terrorCode;
+
public:
- Dbtup(const class Configuration &);
+ Dbtup(Block_context&, Pgman*);
virtual ~Dbtup();
/*
@@ -1086,6 +1401,23 @@
*/
bool tuxQueryTh(Uint32 fragPtrI, Uint32 tupAddr, Uint32 tupVersion, Uint32 transId1, Uint32 transId2, Uint32 savePointId);
+ int load_diskpage(Signal*, Uint32 opRec, Uint32 fragPtrI,
+ Uint32 local_key, Uint32 flags);
+
+ int load_diskpage_scan(Signal*, Uint32 opRec, Uint32 fragPtrI,
+ Uint32 local_key, Uint32 flags);
+
+ int alloc_page(Tablerec*, Fragrecord*, PagePtr*,Uint32 page_no);
+
+ void start_restore_lcp(Uint32 tableId, Uint32 fragmentId);
+ void complete_restore_lcp(Uint32 tableId, Uint32 fragmentId);
+
+ int nr_read_pk(Uint32 fragPtr, const Local_key*, Uint32* dataOut, bool©);
+ int nr_update_gci(Uint32 fragPtr, const Local_key*, Uint32 gci);
+ int nr_delete(Signal*, Uint32, Uint32 fragPtr, const Local_key*, Uint32 gci);
+
+ void nr_delete_page_callback(Signal*, Uint32 op, Uint32 page);
+ void nr_delete_logbuffer_callback(Signal*, Uint32 op, Uint32 page);
private:
BLOCK_DEFINES(Dbtup);
@@ -1094,6 +1426,7 @@
void execCONTINUEB(Signal* signal);
// Received signals
+ void execLCP_FRAG_ORD(Signal*signal);
void execDUMP_STATE_ORD(Signal* signal);
void execSEND_PACKED(Signal* signal);
void execSTTOR(Signal* signal);
@@ -1108,19 +1441,11 @@
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 execFSCLOSECONF(Signal* signal);
- void execFSWRITECONF(Signal* signal);
- void execFSREADCONF(Signal* signal);
void execNDB_STTOR(Signal* signal);
void execREAD_CONFIG_REQ(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 execTUP_ALLOCREQ(Signal* signal);
void execTUP_DEALLOCREQ(Signal* signal);
void execTUP_WRITELOG_REQ(Signal* signal);
@@ -1133,6 +1458,9 @@
void execACC_SCANREQ(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);
//------------------------------------------------------------------
//------------------------------------------------------------------
@@ -1315,10 +1643,15 @@
//------------------------------------------------------------------
//------------------------------------------------------------------
void execTUPKEYREQ(Signal* signal);
+ void disk_page_load_callback(Signal*, Uint32 op, Uint32 page);
+ void disk_page_load_scan_callback(Signal*, Uint32 op, Uint32 page);
//------------------------------------------------------------------
//------------------------------------------------------------------
void execATTRINFO(Signal* signal);
+public:
+ void receive_attrinfo(Signal*, Uint32 op, const Uint32* data, Uint32 len);
+private:
// Trigger signals
//------------------------------------------------------------------
@@ -1335,8 +1668,9 @@
//------------------------------------------------------------------
//------------------------------------------------------------------
void handleATTRINFOforTUPKEYREQ(Signal* signal,
+ const Uint32* data,
Uint32 length,
- Operationrec * const regOperPtr);
+ Operationrec * regOperPtr);
// *****************************************************************
// Setting up the environment for reads, inserts, updates and deletes.
@@ -1344,40 +1678,42 @@
//------------------------------------------------------------------
//------------------------------------------------------------------
int handleReadReq(Signal* signal,
- Operationrec* const regOperPtr,
- Tablerec* const regTabPtr,
- Page* pagePtr);
+ Operationrec* regOperPtr,
+ Tablerec* regTabPtr,
+ KeyReqStruct* req_struct);
//------------------------------------------------------------------
//------------------------------------------------------------------
int handleUpdateReq(Signal* signal,
- Operationrec* const regOperPtr,
- Fragrecord* const regFragPtr,
- Tablerec* const regTabPtr,
- Page* const pagePtr);
+ Operationrec* regOperPtr,
+ Fragrecord* regFragPtr,
+ Tablerec* regTabPtr,
+ KeyReqStruct* req_struct,
+ bool disk);
//------------------------------------------------------------------
//------------------------------------------------------------------
int handleInsertReq(Signal* signal,
- Operationrec* const regOperPtr,
- Fragrecord* const regFragPtr,
- Tablerec* const regTabPtr,
- Page* const pagePtr);
+ Ptr<Operationrec> regOperPtr,
+ Ptr<Fragrecord>,
+ Tablerec* regTabPtr,
+ KeyReqStruct* req_struct);
//------------------------------------------------------------------
//------------------------------------------------------------------
int handleDeleteReq(Signal* signal,
- Operationrec* const regOperPtr,
- Fragrecord* const regFragPtr,
- Tablerec* const regTabPtr,
- Page* const pagePtr);
+ Operationrec* regOperPtr,
+ Fragrecord* regFragPtr,
+ Tablerec* regTabPtr,
+ KeyReqStruct* req_struct);
//------------------------------------------------------------------
//------------------------------------------------------------------
int updateStartLab(Signal* signal,
- Operationrec* const regOperPtr,
- Tablerec* const regTabPtr,
- Page* const pagePtr);
+ Operationrec* regOperPtr,
+ Fragrecord* regFragPtr,
+ Tablerec* regTabPtr,
+ KeyReqStruct* req_struct);
// *****************************************************************
// Interpreter Handling methods.
@@ -1386,14 +1722,12 @@
//------------------------------------------------------------------
//------------------------------------------------------------------
int interpreterStartLab(Signal* signal,
- Page* const pagePtr,
- Uint32 TupHeadOffset);
+ KeyReqStruct *req_struct);
//------------------------------------------------------------------
//------------------------------------------------------------------
int interpreterNextLab(Signal* signal,
- Page* const pagePtr,
- Uint32 TupHeadOffset,
+ KeyReqStruct *req_struct,
Uint32* logMemory,
Uint32* mainProgram,
Uint32 TmainProgLen,
@@ -1408,20 +1742,21 @@
//------------------------------------------------------------------
//------------------------------------------------------------------
void sendReadAttrinfo(Signal* signal,
+ KeyReqStruct *req_struct,
Uint32 TnoOfData,
- const Operationrec * const regOperPtr);
+ const Operationrec * regOperPtr);
//------------------------------------------------------------------
//------------------------------------------------------------------
void sendLogAttrinfo(Signal* signal,
Uint32 TlogSize,
- Operationrec * const regOperPtr);
+ Operationrec * regOperPtr);
//------------------------------------------------------------------
//------------------------------------------------------------------
- void sendTUPKEYCONF(Signal* signal, Operationrec *
- const regOperPtr,
- Uint32 TlogSize);
+ void sendTUPKEYCONF(Signal* signal,
+ KeyReqStruct *req_struct,
+ Operationrec * regOperPtr);
//------------------------------------------------------------------
//------------------------------------------------------------------
@@ -1431,8 +1766,7 @@
// *****************************************************************
//------------------------------------------------------------------
//------------------------------------------------------------------
- int readAttributes(Page* const pagePtr,
- Uint32 TupHeadOffset,
+ int readAttributes(KeyReqStruct* req_struct,
const Uint32* inBuffer,
Uint32 inBufLen,
Uint32* outBuffer,
@@ -1441,273 +1775,227 @@
//------------------------------------------------------------------
//------------------------------------------------------------------
- int readAttributesWithoutHeader(Page* const pagePtr,
- Uint32 TupHeadOffset,
- Uint32* inBuffer,
- Uint32 inBufLen,
- Uint32* outBuffer,
- Uint32* attrBuffer,
- Uint32 TmaxRead);
-
-//------------------------------------------------------------------
-//------------------------------------------------------------------
- int updateAttributes(Page* const pagePtr,
- Uint32 TupHeadOffset,
+ int updateAttributes(KeyReqStruct *req_struct,
Uint32* inBuffer,
Uint32 inBufLen);
//------------------------------------------------------------------
//------------------------------------------------------------------
bool readFixedSizeTHOneWordNotNULL(Uint32* outBuffer,
+ KeyReqStruct *req_struct,
AttributeHeader* ahOut,
- Uint32 attrDescriptor,
Uint32 attrDes2);
//------------------------------------------------------------------
//------------------------------------------------------------------
bool updateFixedSizeTHOneWordNotNULL(Uint32* inBuffer,
- Uint32 attrDescriptor,
+ KeyReqStruct *req_struct,
Uint32 attrDes2);
//------------------------------------------------------------------
//------------------------------------------------------------------
bool readFixedSizeTHTwoWordNotNULL(Uint32* outBuffer,
+ KeyReqStruct *req_struct,
AttributeHeader* ahOut,
- Uint32 attrDescriptor,
Uint32 attrDes2);
//------------------------------------------------------------------
//------------------------------------------------------------------
bool updateFixedSizeTHTwoWordNotNULL(Uint32* inBuffer,
- Uint32 attrDescriptor,
+ KeyReqStruct *req_struct,
Uint32 attrDes2);
//------------------------------------------------------------------
//------------------------------------------------------------------
bool readFixedSizeTHManyWordNotNULL(Uint32* outBuffer,
+ KeyReqStruct *req_struct,
AttributeHeader* ahOut,
- Uint32 attrDescriptor,
Uint32 attrDes2);
//------------------------------------------------------------------
//------------------------------------------------------------------
bool updateFixedSizeTHManyWordNotNULL(Uint32* inBuffer,
- Uint32 attrDescriptor,
+ KeyReqStruct *req_struct,
Uint32 attrDes2);
//------------------------------------------------------------------
//------------------------------------------------------------------
bool readFixedSizeTHOneWordNULLable(Uint32* outBuffer,
+ KeyReqStruct *req_struct,
AttributeHeader* ahOut,
- Uint32 attrDescriptor,
Uint32 attrDes2);
//------------------------------------------------------------------
//------------------------------------------------------------------
bool updateFixedSizeTHOneWordNULLable(Uint32* inBuffer,
- Uint32 attrDescriptor,
+ KeyReqStruct *req_struct,
Uint32 attrDes2);
//------------------------------------------------------------------
//------------------------------------------------------------------
bool readFixedSizeTHTwoWordNULLable(Uint32* outBuffer,
+ KeyReqStruct *req_struct,
AttributeHeader* ahOut,
- Uint32 attrDescriptor,
Uint32 attrDes2);
//------------------------------------------------------------------
//------------------------------------------------------------------
bool updateFixedSizeTHTwoWordNULLable(Uint32* inBuffer,
- Uint32 attrDescriptor,
+ KeyReqStruct *req_struct,
Uint32 attrDes2);
//------------------------------------------------------------------
//------------------------------------------------------------------
bool readFixedSizeTHManyWordNULLable(Uint32* outBuffer,
+ KeyReqStruct *req_struct,
AttributeHeader* ahOut,
- Uint32 attrDescriptor,
Uint32 attrDes2);
//------------------------------------------------------------------
//------------------------------------------------------------------
bool readFixedSizeTHZeroWordNULLable(Uint32* outBuffer,
+ KeyReqStruct *req_struct,
AttributeHeader* ahOut,
- Uint32 attrDescriptor,
Uint32 attrDes2);
//------------------------------------------------------------------
//------------------------------------------------------------------
bool updateFixedSizeTHManyWordNULLable(Uint32* inBuffer,
- Uint32 attrDescriptor,
+ KeyReqStruct *req_struct,
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 readVarSizeNotNULL(Uint32* outBuffer,
+ KeyReqStruct *req_struct,
+ AttributeHeader* ahOut,
+ Uint32 attrDes2);
//------------------------------------------------------------------
//------------------------------------------------------------------
- bool readVarSizeUnlimitedNULLable(Uint32* outBuffer,
- AttributeHeader* ahOut,
- Uint32 attrDescriptor,
- Uint32 attrDes2);
+ bool updateVarSizeNotNULL(Uint32* inBuffer,
+ KeyReqStruct *req_struct,
+ Uint32 attrDes2);
//------------------------------------------------------------------
//------------------------------------------------------------------
- bool updateVarSizeUnlimitedNULLable(Uint32* inBuffer,
- Uint32 attrDescriptor,
- Uint32 attrDes2);
+ bool readVarSizeNULLable(Uint32* outBuffer,
+ KeyReqStruct *req_struct,
+ AttributeHeader* ahOut,
+ Uint32 attrDes2);
//------------------------------------------------------------------
//------------------------------------------------------------------
- bool readBigVarSizeNotNULL(Uint32* outBuffer,
- AttributeHeader* ahOut,
- Uint32 attrDescriptor,
+ bool updateVarSizeNULLable(Uint32* inBuffer,
+ KeyReqStruct *req_struct,
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,
+ KeyReqStruct *req_struct,
AttributeHeader* ahOut,
- Uint32 attrDescriptor,
Uint32 attrDes2);
//------------------------------------------------------------------
//------------------------------------------------------------------
bool updateDynFixedSize(Uint32* inBuffer,
- Uint32 attrDescriptor,
+ KeyReqStruct *req_struct,
Uint32 attrDes2);
//------------------------------------------------------------------
//------------------------------------------------------------------
- bool readDynVarSizeUnlimited(Uint32* outBuffer,
- AttributeHeader* ahOut,
- Uint32 attrDescriptor,
- Uint32 attrDes2);
+ bool readDynVarSize(Uint32* outBuffer,
+ KeyReqStruct *req_struct,
+ AttributeHeader* ahOut,
+ Uint32 attrDes2);
//------------------------------------------------------------------
//------------------------------------------------------------------
- bool updateDynVarSizeUnlimited(Uint32* inBuffer,
- Uint32 attrDescriptor,
- Uint32 attrDes2);
+ bool updateDynVarSize(Uint32* inBuffer,
+ KeyReqStruct *req_struct,
+ Uint32 attrDes2);
-//------------------------------------------------------------------
-//------------------------------------------------------------------
- bool readDynBigVarSize(Uint32* outBuffer,
- AttributeHeader* ahOut,
- Uint32 attrDescriptor,
- Uint32 attrDes2);
+ bool readCharNotNULL(Uint32* outBuffer,
+ KeyReqStruct *req_struct,
+ AttributeHeader* ahOut,
+ Uint32 attrDes2);
-//------------------------------------------------------------------
-//------------------------------------------------------------------
- bool updateDynBigVarSize(Uint32* inBuffer,
- Uint32 attrDescriptor,
- Uint32 attrDes2);
+ bool readCharNULLable(Uint32* outBuffer,
+ KeyReqStruct *req_struct,
+ AttributeHeader* ahOut,
+ Uint32 attrDes2);
-//------------------------------------------------------------------
-//------------------------------------------------------------------
- bool readDynSmallVarSize(Uint32* outBuffer,
- AttributeHeader* ahOut,
- Uint32 attrDescriptor,
- Uint32 attrDes2);
+ bool readBitsNULLable(Uint32* outBuffer, KeyReqStruct *req_struct, AttributeHeader*, Uint32);
+ bool updateBitsNULLable(Uint32* inBuffer, KeyReqStruct *req_struct, Uint32);
+ bool readBitsNotNULL(Uint32* outBuffer, KeyReqStruct *req_struct, AttributeHeader*, Uint32);
+ bool updateBitsNotNULL(Uint32* inBuffer, KeyReqStruct *req_struct, Uint32);
+
+ bool updateFixedNULLable(Uint32* inBuffer, KeyReqStruct *req_struct, Uint32);
+ bool updateFixedNotNull(Uint32* inBuffer, KeyReqStruct *req_struct, Uint32);
+
+ bool updateVarNULLable(Uint32* inBuffer, KeyReqStruct *req_struct, Uint32);
+ bool updateVarNotNull(Uint32* inBuffer, KeyReqStruct *req_struct, Uint32);
+
+
+ bool readDiskFixedSizeNotNULL(Uint32* outBuffer,
+ KeyReqStruct *req_struct,
+ AttributeHeader* ahOut,
+ Uint32 attrDes2);
+
+ bool readDiskFixedSizeNULLable(Uint32* outBuffer,
+ KeyReqStruct *req_struct,
+ AttributeHeader* ahOut,
+ Uint32 attrDes2);
+ bool readDiskVarSizeNULLable(Uint32* outBuffer, KeyReqStruct *req_struct, AttributeHeader*, Uint32);
+ bool readDiskVarSizeNotNULL(Uint32* outBuffer, KeyReqStruct *req_struct, AttributeHeader*, Uint32);
-//------------------------------------------------------------------
-//------------------------------------------------------------------
- bool updateDynSmallVarSize(Uint32* inBuffer,
- Uint32 attrDescriptor,
- Uint32 attrDes2);
+ bool updateDiskFixedSizeNULLable(Uint32*, KeyReqStruct*, Uint32);
+ bool updateDiskFixedSizeNotNULL(Uint32*, KeyReqStruct*, Uint32);
+ bool updateDiskVarSizeNULLable(Uint32*, KeyReqStruct *, Uint32);
+ bool updateDiskVarSizeNotNULL(Uint32*, KeyReqStruct *, Uint32);
+
+ bool readDiskBitsNULLable(Uint32*, KeyReqStruct*, AttributeHeader*, Uint32);
+ bool readDiskBitsNotNULL(Uint32*, KeyReqStruct*, AttributeHeader*, Uint32);
+ bool updateDiskBitsNULLable(Uint32*, KeyReqStruct*, Uint32);
+ bool updateDiskBitsNotNULL(Uint32*, KeyReqStruct*, Uint32);
- bool readBitsNULLable(Uint32* outBuffer, AttributeHeader*, Uint32, Uint32);
- bool updateBitsNULLable(Uint32* inBuffer, Uint32, Uint32);
- bool readBitsNotNULL(Uint32* outBuffer, AttributeHeader*, Uint32, Uint32);
- bool updateBitsNotNULL(Uint32* inBuffer, Uint32, Uint32);
//------------------------------------------------------------------
//------------------------------------------------------------------
- bool nullFlagCheck(Uint32 attrDes2);
- Uint32 read_psuedo(Uint32 attrId, Uint32* outBuffer);
+ bool nullFlagCheck(KeyReqStruct *req_struct, Uint32 attrDes2);
+ bool disk_nullFlagCheck(KeyReqStruct *req_struct, Uint32 attrDes2);
+ Uint32 read_pseudo(Uint32 attrId,
+ KeyReqStruct *req_struct,
+ Uint32* outBuffer);
//------------------------------------------------------------------
//------------------------------------------------------------------
- void setUpQueryRoutines(Tablerec* const regTabPtr);
+ void setUpQueryRoutines(Tablerec* regTabPtr);
// *****************************************************************
// Service methods.
// *****************************************************************
+ TransState get_trans_state(Operationrec * const);
+ void set_trans_state(Operationrec * const, TransState);
+ TupleState get_tuple_state(Operationrec * const);
+ void set_tuple_state(Operationrec * const, TupleState);
+ Uint32 get_frag_page_id(Uint32 real_page_id);
+ Uint32 get_fix_page_offset(Uint32 page_index, Uint32 tuple_size);
+
+ Uint32 decr_tup_version(Uint32 tuple_version);
+ void set_change_mask_state(Operationrec * const, ChangeMaskState);
+ ChangeMaskState get_change_mask_state(Operationrec * const);
+ void update_change_mask_info(KeyReqStruct * const, Operationrec * const);
+ void set_change_mask_info(KeyReqStruct * const, Operationrec * const);
+
//------------------------------------------------------------------
//------------------------------------------------------------------
- void copyAttrinfo(Signal* signal, Operationrec * const regOperPtr, Uint32* inBuffer);
+ void copyAttrinfo(Operationrec * regOperPtr, Uint32* inBuffer);
//------------------------------------------------------------------
//------------------------------------------------------------------
- void initOpConnection(Operationrec* regOperPtr, Fragrecord*);
+ void initOpConnection(Operationrec* regOperPtr);
//------------------------------------------------------------------
//------------------------------------------------------------------
@@ -1715,20 +2003,16 @@
//------------------------------------------------------------------
//------------------------------------------------------------------
- int initStoredOperationrec(Operationrec* const regOperPtr,
+ int initStoredOperationrec(Operationrec* regOperPtr,
+ KeyReqStruct* req_struct,
Uint32 storedId);
//------------------------------------------------------------------
//------------------------------------------------------------------
- void insertActiveOpList(Signal* signal,
- OperationrecPtr regOperPtr,
- Page * const pagePtr,
- Uint32 pageOffset);
+ bool insertActiveOpList(OperationrecPtr, KeyReqStruct* req_struct);
//------------------------------------------------------------------
//------------------------------------------------------------------
- void linkOpIntoFragList(OperationrecPtr regOperPtr,
- Fragrecord* const regFragPtr);
//------------------------------------------------------------------
//------------------------------------------------------------------
@@ -1737,64 +2021,72 @@
//------------------------------------------------------------------
// Trigger handling routines
//------------------------------------------------------------------
- ArrayList<TupTriggerData>* findTriggerList(Tablerec* table,
- TriggerType::Value ttype,
- TriggerActionTime::Value ttime,
- TriggerEvent::Value tevent);
+ DLList<TupTriggerData>*
+ 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);
+ Uint32 dropTrigger(Tablerec* table,
+ const DropTrigReq* req,
+ BlockNumber sender);
+
+ void
+ checkImmediateTriggersAfterInsert(KeyReqStruct *req_struct,
+ Operationrec* regOperPtr,
+ Tablerec* tablePtr);
+
+ void
+ checkImmediateTriggersAfterUpdate(KeyReqStruct *req_struct,
+ Operationrec* regOperPtr,
+ Tablerec* tablePtr);
+
+ void
+ checkImmediateTriggersAfterDelete(KeyReqStruct *req_struct,
+ Operationrec* regOperPtr,
+ Tablerec* tablePtr);
#if 0
void checkDeferredTriggers(Signal* signal,
- Operationrec* const regOperPtr,
- Tablerec* const regTablePtr);
+ Operationrec* regOperPtr,
+ Tablerec* regTablePtr);
#endif
- void checkDetachedTriggers(Signal* signal,
- Operationrec* const regOperPtr,
- Tablerec* const regTablePtr);
-
- void fireImmediateTriggers(Signal* signal,
- ArrayList<TupTriggerData>& triggerList,
- Operationrec* const regOperPtr);
-
- void fireDeferredTriggers(Signal* signal,
- ArrayList<TupTriggerData>& triggerList,
- Operationrec* const regOperPtr);
-
- void fireDetachedTriggers(Signal* signal,
- ArrayList<TupTriggerData>& triggerList,
- Operationrec* const regOperPtr);
-
- void executeTriggers(Signal* signal,
- ArrayList<TupTriggerData>& 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,
+ void checkDetachedTriggers(KeyReqStruct *req_struct,
+ Operationrec* regOperPtr,
+ Tablerec* regTablePtr);
+
+ void fireImmediateTriggers(KeyReqStruct *req_struct,
+ DLList<TupTriggerData>& triggerList,
+ Operationrec* regOperPtr);
+
+ void fireDeferredTriggers(KeyReqStruct *req_struct,
+ DLList<TupTriggerData>& triggerList,
+ Operationrec* regOperPtr);
+
+ void fireDetachedTriggers(KeyReqStruct *req_struct,
+ DLList<TupTriggerData>& triggerList,
+ Operationrec* regOperPtr);
+
+ void executeTriggers(KeyReqStruct *req_struct,
+ DLList<TupTriggerData>& triggerList,
+ Operationrec* regOperPtr);
+
+ void executeTrigger(KeyReqStruct *req_struct,
+ TupTriggerData* trigPtr,
+ Operationrec* regOperPtr);
+
+ bool readTriggerInfo(TupTriggerData* trigPtr,
+ Operationrec* regOperPtr,
+ KeyReqStruct * req_struct,
+ Fragrecord* regFragPtr,
+ Uint32* keyBuffer,
Uint32& noPrimKey,
- Uint32* const mainBuffer,
- Uint32& noMainWords,
- Uint32* const copyBuffer,
- Uint32& noCopyWords);
+ Uint32* afterBuffer,
+ Uint32& noAfterWords,
+ Uint32* beforeBuffer,
+ Uint32& noBeforeWords);
void sendTrigAttrInfo(Signal* signal,
Uint32* data,
@@ -1807,8 +2099,10 @@
Uint32* inBuffer);
void sendFireTrigOrd(Signal* signal,
- Operationrec * const regOperPtr,
- TupTriggerData* const trigPtr,
+ KeyReqStruct *req_struct,
+ Operationrec * regOperPtr,
+ TupTriggerData* trigPtr,
+ Uint32 fragmentId,
Uint32 noPrimKeySignals,
Uint32 noBeforeSignals,
Uint32 noAfterSignals);
@@ -1818,16 +2112,19 @@
// these set terrorCode and return non-zero on error
int executeTuxInsertTriggers(Signal* signal,
- Operationrec* const regOperPtr,
- Tablerec* const regTabPtr);
+ Operationrec* regOperPtr,
+ Fragrecord* regFragPtr,
+ Tablerec* regTabPtr);
int executeTuxUpdateTriggers(Signal* signal,
- Operationrec* const regOperPtr,
- Tablerec* const regTabPtr);
+ Operationrec* regOperPtr,
+ Fragrecord* regFragPtr,
+ Tablerec* regTabPtr);
int executeTuxDeleteTriggers(Signal* signal,
- Operationrec* const regOperPtr,
- Tablerec* const regTabPtr);
+ Operationrec* regOperPtr,
+ Fragrecord* regFragPtr,
+ Tablerec* regTabPtr);
int addTuxEntries(Signal* signal,
Operationrec* regOperPtr,
@@ -1837,14 +2134,15 @@
void executeTuxCommitTriggers(Signal* signal,
Operationrec* regOperPtr,
- Tablerec* const regTabPtr);
+ Fragrecord* regFragPtr,
+ Tablerec* regTabPtr);
void executeTuxAbortTriggers(Signal* signal,
Operationrec* regOperPtr,
- Tablerec* const regTabPtr);
+ Fragrecord* regFragPtr,
+ Tablerec* regTabPtr);
void removeTuxEntries(Signal* signal,
- Operationrec* regOperPtr,
Tablerec* regTabPtr);
// *****************************************************************
@@ -1882,7 +2180,7 @@
//
// 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
+// we will set the delete state on the record that becomes the ownerd
// of the record.
//
// Commit of Update:
@@ -1922,84 +2220,87 @@
//------------------------------------------------------------------
//------------------------------------------------------------------
-#if 0
- void checkPages(Fragrecord* const regFragPtr);
+#if 0
+ void checkPages(Fragrecord* regFragPtr);
#endif
- void printoutTuplePage(Uint32 fragid, Uint32 pageid, Uint32 printLimit);
+ Uint32 convert_byte_to_word_size(Uint32 byte_size)
+ {
+ return ((byte_size + 3) >> 2);
+ }
+ Uint32 convert_bit_to_word_size(Uint32 bit_size)
+ {
+ return ((bit_size + 31) >> 5);
+ }
+
+ void prepare_initial_insert(KeyReqStruct*, Operationrec*, Tablerec*);
+ void fix_disk_insert_no_mem_insert(KeyReqStruct*, Operationrec*, Tablerec*);
+ void setup_fixed_part(KeyReqStruct* req_struct,
+ Operationrec* regOperPtr,
+ Tablerec* regTabPtr);
+
+ void send_TUPKEYREF(Signal* signal,
+ Operationrec* regOperPtr);
+ void early_tupkey_error(Signal* signal);
- bool checkUpdateOfPrimaryKey(Uint32* updateBuffer, Tablerec* const regTabPtr);
+ void printoutTuplePage(Uint32 fragid, Uint32 pageid, Uint32 printLimit);
- 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);
+ bool checkUpdateOfPrimaryKey(KeyReqStruct *req_struct,
+ Uint32* updateBuffer,
+ Tablerec* regTabPtr);
+
+ void setNullBits(Uint32*, Tablerec* regTabPtr);
+ bool checkNullAttributes(KeyReqStruct * const, Tablerec* const);
+ bool setup_read(KeyReqStruct* req_struct,
+ Operationrec* regOperPtr,
+ Fragrecord* regFragPtr,
+ Tablerec* regTabPtr,
+ bool disk);
+
+ Uint32 calculateChecksum(Tuple_header*, Tablerec* regTabPtr);
+ void setChecksum(Tuple_header*, Tablerec* regTabPtr);
- void setTupleStatesSetOpType(Operationrec* const regOperPtr,
- Page* const pagePtr,
+ void complexTrigger(Signal* signal,
+ KeyReqStruct *req_struct,
+ Operationrec* regOperPtr,
+ Fragrecord* regFragPtr,
+ Tablerec* regTabPtr);
+
+ void setTupleStatesSetOpType(Operationrec* regOperPtr,
+ KeyReqStruct *req_struct,
+ Page* pagePtr,
Uint32& opType,
OperationrecPtr& firstOpPtr);
void findBeforeValueOperation(OperationrecPtr& befOpPtr,
OperationrecPtr firstOpPtr);
- void calculateChangeMask(Page* const PagePtr,
- Tablerec* const regTabPtr,
- Uint32 pageOffset,
- Bitmask<MAXNROFATTRIBUTESINWORDS>& 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 calculateChangeMask(Page* PagePtr,
+ Tablerec* regTabPtr,
+ KeyReqStruct * req_struct);
+
+ void updateGcpId(KeyReqStruct *req_struct,
+ Operationrec* regOperPtr,
+ Fragrecord* regFragPtr,
+ Tablerec* 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 removeActiveOpList(Operationrec* const regOperPtr, Tuple_header*);
void updatePackedList(Signal* signal, Uint16 ahostIndex);
void setUpDescriptorReferences(Uint32 descriptorReference,
- Tablerec* const regTabPtr,
+ Tablerec* regTabPtr,
const Uint32* offset);
- void setUpKeyArray(Tablerec* const regTabPtr);
- bool addfragtotab(Tablerec* const regTabPtr, Uint32 fragId, Uint32 fragIndex);
- void deleteFragTab(Tablerec* const regTabPtr, Uint32 fragId);
+ void setUpKeyArray(Tablerec* regTabPtr);
+ bool addfragtotab(Tablerec* regTabPtr, Uint32 fragId, Uint32 fragIndex);
+ void deleteFragTab(Tablerec* regTabPtr, Uint32 fragId);
void abortAddFragOp(Signal* signal);
- void releaseTabDescr(Tablerec* const regTabPtr);
- void getFragmentrec(FragrecordPtr& regFragPtr, Uint32 fragId, Tablerec* const regTabPtr);
+ void releaseTabDescr(Tablerec* regTabPtr);
+ void getFragmentrec(FragrecordPtr& regFragPtr, Uint32 fragId, Tablerec* regTabPtr);
void initialiseRecordsLab(Signal* signal, Uint32 switchData, Uint32, Uint32);
void initializeAttrbufrec();
@@ -2016,7 +2317,7 @@
void initializeTabDescr();
void initializeUndoPage();
- void initTab(Tablerec* const regTabPtr);
+ void initTab(Tablerec* regTabPtr);
void startphase3Lab(Signal* signal, Uint32 config1, Uint32 config2);
@@ -2026,143 +2327,30 @@
void fragrefuse3Lab(Signal* signal,
FragoperrecPtr fragOperPtr,
FragrecordPtr regFragPtr,
- Tablerec* const regTabPtr,
+ Tablerec* regTabPtr,
Uint32 fragId);
void fragrefuse4Lab(Signal* signal,
FragoperrecPtr fragOperPtr,
FragrecordPtr regFragPtr,
- Tablerec* const regTabPtr,
+ Tablerec* regTabPtr,
Uint32 fragId);
void addattrrefuseLab(Signal* signal,
FragrecordPtr regFragPtr,
FragoperrecPtr fragOperPtr,
- Tablerec* const regTabPtr,
+ Tablerec* 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);
-
+ void drop_fragment_free_var_pages(Signal*);
+ void drop_fragment_free_exent(Signal*, TablerecPtr, FragrecordPtr, Uint32);
+ void drop_fragment_unmap_pages(Signal*, TablerecPtr, FragrecordPtr, Uint32);
+ void drop_fragment_unmap_page_callback(Signal* signal, Uint32, Uint32);
+
// 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,
@@ -2174,8 +2362,8 @@
Operationrec* regOperPtr);
bool storedProcedureAttrInfo(Signal* signal,
Operationrec* regOperPtr,
+ const Uint32* data,
Uint32 length,
- Uint32 firstWord,
bool copyProc);
//-----------------------------------------------------------------------------
@@ -2198,10 +2386,15 @@
void verifytabdes();
#endif
-//------------------------------------------------------------------------------------------------------
+ void seizeOpRec(OperationrecPtr& regOperPtr);
+ void seizeFragrecord(FragrecordPtr& regFragPtr);
+ void seizeFragoperrec(FragoperrecPtr& fragOperPtr);
+ void releaseFragoperrec(FragoperrecPtr fragOperPtr);
+ void releaseFragrec(FragrecordPtr);
+//----------------------------------------------------------------------------
// Page Memory Manager
-//------------------------------------------------------------------------------------------------------
-
+//----------------------------------------------------------------------------
+
// Public methods
void allocConsPages(Uint32 noOfPagesToAllocate,
Uint32& noOfPagesAllocated,
@@ -2225,24 +2418,25 @@
//------------------------------------------------------------------------------------------------------
//
// Public methods
- Uint32 getRealpid(Fragrecord* const regFragPtr, Uint32 logicalPageId);
- Uint32 getNoOfPages(Fragrecord* const regFragPtr);
+ Uint32 getRealpid(Fragrecord* regFragPtr, Uint32 logicalPageId);
+ Uint32 getNoOfPages(Fragrecord* regFragPtr);
void initPageRangeSize(Uint32 size);
- bool insertPageRangeTab(Fragrecord* const regFragPtr,
+ bool insertPageRangeTab(Fragrecord* regFragPtr,
Uint32 startPageId,
Uint32 noPages);
- void releaseFragPages(Fragrecord* const regFragPtr);
- void initFragRange(Fragrecord* const regFragPtr);
+ void releaseFragPages(Fragrecord* regFragPtr);
+ void initFragRange(Fragrecord* regFragPtr);
void initializePageRange();
- Uint32 getEmptyPage(Fragrecord* const regFragPtr);
- Uint32 allocFragPages(Fragrecord* const regFragPtr, Uint32 noOfPagesAllocated);
-
+ Uint32 getEmptyPage(Fragrecord* regFragPtr);
+ Uint32 allocFragPages(Fragrecord* regFragPtr, Uint32 noOfPagesAllocated);
+ Uint32 get_empty_var_page(Fragrecord* frag_ptr);
+
// Private methods
- Uint32 leafPageRangeFull(Fragrecord* const regFragPtr, PageRangePtr currPageRangePtr);
+ Uint32 leafPageRangeFull(Fragrecord* regFragPtr, PageRangePtr currPageRangePtr);
void releasePagerange(PageRangePtr regPRPtr);
void seizePagerange(PageRangePtr& regPageRangePtr);
void errorHandler(Uint32 errorCode);
- void allocMoreFragPages(Fragrecord* const regFragPtr);
+ void allocMoreFragPages(Fragrecord* regFragPtr);
// Private data
Uint32 cfirstfreerange;
@@ -2250,89 +2444,80 @@
Uint32 c_noOfFreePageRanges;
Uint32 cnoOfPageRangeRec;
-//------------------------------------------------------------------------------------------------------
-// Fixed Allocator
+//---------------------------------------------------------------
+// Variable 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);
+ void init_list_sizes(void);
// 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);
+ Uint32 get_alloc_page(Fragrecord* const, Uint32);
+ void update_free_page_list(Fragrecord* const, Ptr<Page>);
-//------------------------------------------------------------------------------------------------------
-// Temporary variables used for storing commonly used variables in certain modules
-//------------------------------------------------------------------------------------------------------
+#if 0
+ Uint32 calc_free_list(const Tablerec* regTabPtr, Uint32 sz) const {
+ return regTabPtr->m_disk_alloc_info.calc_page_free_bits(sz);
+ }
+#endif
+
+ Uint32 calculate_free_list_impl(Uint32) const ;
+ void remove_free_page(Fragrecord*, Var_page*, Uint32);
+ void insert_free_page(Fragrecord*, Var_page*, Uint32);
+//---------------------------------------------------------------
+// Fixed Allocator
+// Allocates and deallocates tuples of fixed size on a fragment.
+//---------------------------------------------------------------
+//
+// Public methods
+ Uint32* alloc_var_rec(Fragrecord*, Tablerec*, Uint32, Local_key*, Uint32*);
+ void free_var_rec(Fragrecord*, Tablerec*, Local_key*, Ptr<Page>);
+ Uint32* alloc_var_part(Fragrecord*, Tablerec*, Uint32, Local_key*);
+ int realloc_var_part(Fragrecord*, Tablerec*,
+ PagePtr, Var_part_ref*, Uint32, Uint32);
+
+ void validate_page(Tablerec*, Var_page* page);
+
+ Uint32* alloc_fix_rec(Fragrecord*const, Tablerec*const, Local_key*,
+ Uint32*);
+ void free_fix_rec(Fragrecord*, Tablerec*, Local_key*, Fix_page*);
+
+ Uint32* alloc_fix_rowid(Fragrecord*, Tablerec*, Local_key*, Uint32 *);
+ Uint32* alloc_var_rowid(Fragrecord*, Tablerec*, Uint32, Local_key*, Uint32*);
+// Private methods
+ void convertThPage(Fix_page* regPagePtr,
+ Tablerec*,
+ Uint32 mm);
+
+ /**
+ * Return offset
+ */
+ Uint32 alloc_tuple_from_page(Fragrecord* regFragPtr,
+ Fix_page* regPagePtr);
+
+//---------------------------------------------------------------
+// Temporary variables used for storing commonly used variables
+// in certain modules
+//---------------------------------------------------------------
+
+ Uint32 c_lcp_scan_op;
FragrecordPtr fragptr;
OperationrecPtr operPtr;
TablerecPtr tabptr;
// readAttributes and updateAttributes module
- Uint32 tCheckOffset;
- Uint32 tMaxRead;
- Uint32 tOutBufIndex;
- Uint32* tTupleHeader;
- bool tXfrmFlag;
-
-// 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;
@@ -2343,39 +2528,17 @@
HostBuffer *hostBuffer;
- LocalLogInfo *localLogInfo;
- Uint32 cnoOfLocalLogInfo;
+ ArrayPool<Operationrec> c_operation_pool;
- Uint32 cfirstfreeOprec;
- Operationrec *operationrec;
- Uint32 cnoOfOprec;
-
- Page *page;
- Uint32 cnoOfPage;
+ ArrayPool<Page> c_page_pool;
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;
@@ -2389,7 +2552,6 @@
Uint32 clqhUserpointer;
Uint32 cminusOne;
BlockReference cndbcntrRef;
- Uint32 cundoFileVersion;
BlockReference cownref;
Uint32 cownNodeId;
Uint32 czero;
@@ -2399,18 +2561,16 @@
Uint32 clogMemBuffer[ZATTR_BUFFER_SIZE + 16];
Uint32 coutBuffer[ZATTR_BUFFER_SIZE + 16];
Uint32 cinBuffer[ZATTR_BUFFER_SIZE + 16];
+ Uint32 ctemp_page[ZWORDS_ON_PAGE];
+ Uint32 ctemp_var_record[ZWORDS_ON_PAGE];
Uint32 totNoOfPagesAllocated;
// Trigger variables
Uint32 c_maxTriggersPerTable;
- // Counters for num UNDO log records executed
- Uint32 cSrUndoRecords[9];
-
- STATIC_CONST(MAX_PARALLELL_TUP_SRREQ = 2);
- Uint32 c_sr_free_page_0;
-
Uint32 c_errorInsert4000TableId;
+ Uint32 c_min_list_size[MAX_FREE_LIST + 1];
+ Uint32 c_max_list_size[MAX_FREE_LIST + 1];
void initGlobalTemporaryVars();
void reportMemoryUsage(Signal* signal, int incDec);
@@ -2423,48 +2583,269 @@
friend class NdbOut& operator<<(NdbOut&, const Operationrec&);
friend class NdbOut& operator<<(NdbOut&, const Th&);
#endif
+
+ void expand_tuple(KeyReqStruct*, Uint32 sizes[4], Tuple_header*org,
+ const Tablerec*, bool disk);
+ void shrink_tuple(KeyReqStruct*, Uint32 sizes[2], const Tablerec*,
+ bool disk);
+
+ Uint32* get_ptr(Var_part_ref);
+ Uint32* get_ptr(PagePtr*, Var_part_ref);
+ Uint32* get_ptr(PagePtr*, const Local_key*, const Tablerec*);
+ Uint32* get_dd_ptr(PagePtr*, const Local_key*, const Tablerec*);
+
+ /**
+ * prealloc space from disk
+ * key.m_file_no contains file no
+ * key.m_page_no contains disk page
+ * key.m_page_idx contains byte preallocated
+ */
+ int disk_page_prealloc(Signal*, Ptr<Fragrecord>, Local_key*, Uint32);
+ void disk_page_prealloc_dirty_page(Disk_alloc_info&,
+ Ptr<Page>, Uint32, Uint32);
+ void disk_page_prealloc_transit_page(Disk_alloc_info&,
+ Ptr<Page_request>, Uint32, Uint32);
+
+ void disk_page_abort_prealloc(Signal*, Fragrecord*,Local_key*, Uint32);
+ void disk_page_abort_prealloc_callback(Signal*, Uint32, Uint32);
+ void disk_page_abort_prealloc_callback_1(Signal*, Fragrecord*,
+ PagePtr, Uint32);
+
+ void disk_page_prealloc_callback(Signal*, Uint32, Uint32);
+ void disk_page_prealloc_initial_callback(Signal*, Uint32, Uint32);
+ void disk_page_prealloc_callback_common(Signal*,
+ Ptr<Page_request>,
+ Ptr<Fragrecord>,
+ Ptr<Page>);
+
+ void disk_page_alloc(Signal*,
+ Tablerec*, Fragrecord*, Local_key*, PagePtr, Uint32);
+ void disk_page_free(Signal*,
+ Tablerec*, Fragrecord*, Local_key*, PagePtr, Uint32);
+
+ void disk_page_commit_callback(Signal*, Uint32 opPtrI, Uint32 page_id);
+
+ void disk_page_log_buffer_callback(Signal*, Uint32 opPtrI, Uint32);
+
+ Uint64 disk_page_undo_alloc(Page*, const Local_key*,
+ Uint32 sz, Uint32 gci, Uint32 logfile_group_id);
+
+ Uint64 disk_page_undo_update(Page*, const Local_key*,
+ const Uint32*, Uint32,
+ Uint32 gci, Uint32 logfile_group_id);
+
+ Uint64 disk_page_undo_free(Page*, const Local_key*,
+ const Uint32*, Uint32 sz,
+ Uint32 gci, Uint32 logfile_group_id);
+
+ void undo_createtable_callback(Signal* signal, Uint32 opPtrI, Uint32 unused);
+ void undo_createtable_logsync_callback(Signal* signal, Uint32, Uint32);
+
+ void disk_page_set_dirty(Ptr<Page>);
+ void restart_setup_page(Disk_alloc_info&, Ptr<Page>);
+ void update_extent_pos(Disk_alloc_info&, Ptr<Extent_info>);
+
+ /**
+ * Disk restart code
+ */
+public:
+ int disk_page_load_hook(Uint32 page_id);
+
+ void disk_page_unmap_callback(Uint32 page_id, Uint32 dirty_count);
+
+ int disk_restart_alloc_extent(Uint32 tableId, Uint32 fragId,
+ const Local_key* key, Uint32 pages);
+ void disk_restart_page_bits(Uint32 tableId, Uint32 fragId,
+ const Local_key*, Uint32 bits);
+ void disk_restart_undo(Signal* signal, Uint64 lsn,
+ Uint32 type, const Uint32 * ptr, Uint32 len);
+
+ struct Apply_undo
+ {
+ Uint32 m_type, m_len;
+ const Uint32* m_ptr;
+ Uint64 m_lsn;
+ Ptr<Tablerec> m_table_ptr;
+ Ptr<Fragrecord> m_fragment_ptr;
+ Ptr<Page> m_page_ptr;
+ Ptr<Extent_info> m_extent_ptr;
+ Local_key m_key;
+ };
+
+private:
+ void disk_restart_undo_next(Signal*);
+ void disk_restart_undo_lcp(Uint32, Uint32);
+ void disk_restart_undo_callback(Signal* signal, Uint32, Uint32);
+ void disk_restart_undo_alloc(Apply_undo*);
+ void disk_restart_undo_update(Apply_undo*);
+ void disk_restart_undo_free(Apply_undo*);
+ void disk_restart_undo_page_bits(Signal*, Apply_undo*);
+
+#ifdef VM_TRACE
+ void verify_page_lists(Disk_alloc_info&);
+#else
+ void verify_page_lists(Disk_alloc_info&) {}
+#endif
+
+ void fix_commit_order(OperationrecPtr);
+ void commit_operation(Signal*, Uint32, Tuple_header*, PagePtr,
+ Operationrec*, Fragrecord*, Tablerec*);
+
+ void dealloc_tuple(Signal* signal, Uint32, Page*, Tuple_header*,
+ Operationrec*, Fragrecord*, Tablerec*);
+
+ int handle_size_change_after_update(KeyReqStruct* req_struct,
+ Tuple_header* org,
+ Operationrec*,
+ Fragrecord* regFragPtr,
+ Tablerec* regTabPtr,
+ Uint32 sizes[4]);
+
+ /**
+ * Setup all pointer on keyreqstruct to prepare for read
+ * req_struct->m_tuple_ptr is set to tuple to read
+ */
+ void prepare_read(KeyReqStruct*, Tablerec* const, bool disk);
};
+#if 0
+inline
+Uint32
+Dbtup::get_frag_page_id(Uint32 real_page_id)
+{
+ PagePtr real_page_ptr;
+ real_page_ptr.i= real_page_id;
+ ptrCheckGuard(real_page_ptr, cnoOfPage, cpage);
+ return real_page_ptr.p->frag_page_id;
+}
+#endif
+
+inline
+Dbtup::TransState
+Dbtup::get_trans_state(Operationrec * regOperPtr)
+{
+ return (Dbtup::TransState)regOperPtr->op_struct.trans_state;
+}
+
+inline
+void
+Dbtup::set_trans_state(Operationrec* regOperPtr,
+ Dbtup::TransState trans_state)
+{
+ regOperPtr->op_struct.trans_state= (Uint32)trans_state;
+}
+
+inline
+Dbtup::TupleState
+Dbtup::get_tuple_state(Operationrec * regOperPtr)
+{
+ return (Dbtup::TupleState)regOperPtr->op_struct.tuple_state;
+}
+
+inline
+void
+Dbtup::set_tuple_state(Operationrec* regOperPtr,
+ Dbtup::TupleState tuple_state)
+{
+ regOperPtr->op_struct.tuple_state= (Uint32)tuple_state;
+}
+
+
+inline
+Uint32
+Dbtup::decr_tup_version(Uint32 tup_version)
+{
+ return (tup_version - 1) & ZTUP_VERSION_MASK;
+}
+
inline
-bool Dbtup::isUndoLoggingNeeded(Fragrecord* const regFragPtr,
- Uint32 pageId)
+Dbtup::ChangeMaskState
+Dbtup::get_change_mask_state(Operationrec * regOperPtr)
{
- if ((regFragPtr->checkpointVersion != RNIL) &&
- (pageId >= regFragPtr->minPageNotWrittenInCheckpoint) &&
- (pageId < regFragPtr->maxPageWrittenInCheckpoint)) {
- return true;
- }//if
- return false;
-}//Dbtup::isUndoLoggingNeeded()
+ return (Dbtup::ChangeMaskState)regOperPtr->op_struct.change_mask_state;
+}
inline
-bool Dbtup::isUndoLoggingActive(Fragrecord* const regFragPtr)
+void
+Dbtup::set_change_mask_state(Operationrec * regOperPtr,
+ ChangeMaskState new_state)
{
- if (regFragPtr->checkpointVersion != RNIL) {
- return true;
- }//if
- return false;
-}//Dbtup::isUndoLoggingNeeded()
+ regOperPtr->op_struct.change_mask_state= (Uint32)new_state;
+}
inline
-bool Dbtup::isUndoLoggingBlocked(Fragrecord* const regFragPtr)
+void
+Dbtup::update_change_mask_info(KeyReqStruct * req_struct,
+ Operationrec * regOperPtr)
{
- if ((regFragPtr->checkpointVersion != RNIL) &&
- (cnoFreeUndoSeg < ZMIN_PAGE_LIMIT_TUPKEYREQ)) {
- return true;
- }//if
- return false;
-}//Dbtup::isUndoLoggingNeeded()
+ if (req_struct->max_attr_id_updated == 0) {
+ if (get_change_mask_state(regOperPtr) == USE_SAVED_CHANGE_MASK) {
+ // add new changes
+ regOperPtr->saved_change_mask[0] |= req_struct->changeMask.getWord(0);
+ regOperPtr->saved_change_mask[1] |= req_struct->changeMask.getWord(1);
+ }
+ } else {
+ if (req_struct->no_changed_attrs < 16) {
+ set_change_mask_state(regOperPtr, RECALCULATE_CHANGE_MASK);
+ } else {
+ set_change_mask_state(regOperPtr, SET_ALL_MASK);
+ }
+ }
+}
inline
-bool Dbtup::isPageUndoLogged(Fragrecord* const regFragPtr,
- Uint32 pageId)
+Uint32*
+Dbtup::get_ptr(Var_part_ref ref)
{
- if ((pageId >= regFragPtr->minPageNotWrittenInCheckpoint) &&
- (pageId < regFragPtr->maxPageWrittenInCheckpoint)) {
- return true;
- }//if
- return false;
-}//Dbtup::isUndoLoggingNeeded()
+ Ptr<Page> tmp;
+ return get_ptr(&tmp, ref);
+}
+
+inline
+Uint32*
+Dbtup::get_ptr(Ptr<Page>* pagePtr, Var_part_ref ref)
+{
+ PagePtr tmp;
+ Uint32 page_idx= ref.m_ref & MAX_TUPLES_PER_PAGE;
+ tmp.i= ref.m_ref >> MAX_TUPLES_BITS;
+
+ c_page_pool.getPtr(tmp);
+ memcpy(pagePtr, &tmp, sizeof(tmp));
+ return ((Var_page*)tmp.p)->get_ptr(page_idx);
+}
+
+inline
+Uint32*
+Dbtup::get_ptr(PagePtr* pagePtr,
+ const Local_key* key, const Tablerec* regTabPtr)
+{
+ PagePtr tmp;
+ tmp.i= key->m_page_no;
+ c_page_pool.getPtr(tmp);
+ memcpy(pagePtr, &tmp, sizeof(tmp));
+
+ return ((Fix_page*)tmp.p)->
+ get_ptr(key->m_page_idx, regTabPtr->m_offsets[MM].m_fix_header_size);
+}
+
+inline
+Uint32*
+Dbtup::get_dd_ptr(PagePtr* pagePtr,
+ const Local_key* key, const Tablerec* regTabPtr)
+{
+ PagePtr tmp;
+ tmp.i= key->m_page_no;
+ tmp.p= (Page*)m_global_page_pool.getPtr(tmp.i);
+ memcpy(pagePtr, &tmp, sizeof(tmp));
+
+ if(regTabPtr->m_attributes[DD].m_no_of_varsize)
+ return ((Var_page*)tmp.p)->get_ptr(key->m_page_idx);
+ else
+ return ((Fix_page*)tmp.p)->
+ get_ptr(key->m_page_idx, regTabPtr->m_offsets[DD].m_fix_header_size);
+}
+
+NdbOut&
+operator<<(NdbOut&, const Dbtup::Tablerec&);
#endif
--- 1.12.3.2/ndb/src/kernel/blocks/dbtup/DbtupMeta.cpp 2006-07-24 02:32:54 +10:00
+++ 1.30/storage/ndb/src/kernel/blocks/dbtup/DbtupMeta.cpp 2006-07-24 02:32:54 +10:00
@@ -25,6 +25,7 @@
#include <signaldata/FsRemoveReq.hpp>
#include <signaldata/DropTab.hpp>
#include <signaldata/AlterTab.hpp>
+#include <signaldata/CreateFilegroupImpl.hpp>
#include <AttributeDescriptor.hpp>
#include "AttributeOffset.hpp"
#include <my_sys.h>
@@ -32,11 +33,6 @@
#define ljam() { jamLine(20000 + __LINE__); }
#define ljamEntry() { jamEntryLine(20000 + __LINE__); }
-/* ---------------------------------------------------------------- */
-/* ---------------------------------------------------------------- */
-/* --------------- ADD/DROP FRAGMENT TABLE MODULE ----------------- */
-/* ---------------------------------------------------------------- */
-/* ---------------------------------------------------------------- */
void Dbtup::execTUPFRAGREQ(Signal* signal)
{
ljamEntry();
@@ -61,13 +57,11 @@
Uint32 noOfNullAttr = tupFragReq->noOfNullAttr;
/* Uint32 schemaVersion = tupFragReq->schemaVersion;*/
Uint32 noOfKeyAttr = tupFragReq->noOfKeyAttr;
-
- Uint32 noOfNewAttr = tupFragReq->noOfNewAttr;
Uint32 noOfCharsets = tupFragReq->noOfCharsets;
Uint32 checksumIndicator = tupFragReq->checksumIndicator;
- Uint32 noOfAttributeGroups = tupFragReq->noOfAttributeGroups;
- Uint32 globalCheckpointIdIndicator = tupFragReq->globalCheckpointIdIndicator;
+ Uint32 gcpIndicator = tupFragReq->globalCheckpointIdIndicator;
+ Uint32 tablespace_id= tupFragReq->tablespaceid;
Uint64 maxRows =
(((Uint64)tupFragReq->maxRowsHigh) << 32) + tupFragReq->maxRowsLow;
@@ -92,7 +86,7 @@
tupFragReq->userRef = ZNOFREE_FRAGOP_ERROR;
sendSignal(userblockref, GSN_TUPFRAGREF, signal, 2, JBB);
return;
- }//if
+ }
seizeFragoperrec(fragOperPtr);
fragOperPtr.p->nextFragoprec = RNIL;
@@ -101,53 +95,56 @@
fragOperPtr.p->fragidFrag = fragId;
fragOperPtr.p->tableidFrag = regTabPtr.i;
fragOperPtr.p->attributeCount = noOfAttributes;
- fragOperPtr.p->noOfNullBits = noOfNullAttr;
- fragOperPtr.p->noOfNewAttrCount = noOfNewAttr;
+
+ memset(fragOperPtr.p->m_null_bits, 0, sizeof(fragOperPtr.p->m_null_bits));
+ memset(fragOperPtr.p->m_fix_attributes_size, 0,
+ sizeof(fragOperPtr.p->m_fix_attributes_size));
+ memset(fragOperPtr.p->m_var_attributes_size, 0,
+ sizeof(fragOperPtr.p->m_var_attributes_size));
+
fragOperPtr.p->charsetIndex = 0;
- fragOperPtr.p->currNullBit = 0;
- // remove in 5.1, 2 fragments per fragment in 5.0
- fragOperPtr.p->minRows = (minRows + 1)/2;
- fragOperPtr.p->maxRows = (maxRows + 1)/2;
+ fragOperPtr.p->minRows = minRows;
+ fragOperPtr.p->maxRows = maxRows;
ndbrequire(reqinfo == ZADDFRAG);
getFragmentrec(regFragPtr, fragId, regTabPtr.p);
if (regFragPtr.i != RNIL) {
ljam();
- terrorCode = ZEXIST_FRAG_ERROR; /* THE FRAGMENT ALREADY EXIST */
+ terrorCode= ZEXIST_FRAG_ERROR;
fragrefuse1Lab(signal, fragOperPtr);
return;
- }//if
+ }
if (cfirstfreefrag != RNIL) {
ljam();
seizeFragrecord(regFragPtr);
} else {
ljam();
- terrorCode = ZFULL_FRAGRECORD_ERROR;
+ 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;
+ terrorCode= ZNO_FREE_TAB_ENTRY_ERROR;
fragrefuse2Lab(signal, fragOperPtr, regFragPtr);
return;
- }//if
+ }
if (cfirstfreerange == RNIL) {
ljam();
- terrorCode = ZNO_FREE_PAGE_RANGE_ERROR;
+ 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;
+ regFragPtr.p->fragTableId= regTabPtr.i;
+ regFragPtr.p->fragmentId= fragId;
+ regFragPtr.p->m_tablespace_id= tablespace_id;
+ regFragPtr.p->m_undo_complete= false;
+ regFragPtr.p->m_lcp_scan_op = RNIL;
+ regFragPtr.p->m_lcp_keep_list = RNIL;
+ regFragPtr.p->m_var_page_chunks = RNIL;
if (ERROR_INSERTED(4007) && regTabPtr.p->fragid[0] == fragId ||
ERROR_INSERTED(4008) && regTabPtr.p->fragid[1] == fragId) {
@@ -160,112 +157,112 @@
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.
+// 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->noOfCharsets = noOfCharsets;
- regTabPtr.p->noOfAttr = noOfAttributes;
- regTabPtr.p->noOfNewAttr = noOfNewAttr;
- regTabPtr.p->noOfNullAttr = noOfNullAttr;
- regTabPtr.p->noOfAttributeGroups = noOfAttributeGroups;
-
+// 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
+//-----------------------------------------------------------------------------
+ fragOperPtr.p->definingFragment= true;
+ regTabPtr.p->tableStatus= DEFINING;
+ regTabPtr.p->m_bits = 0;
+ regTabPtr.p->m_bits |= (checksumIndicator ? Tablerec::TR_Checksum : 0);
+ regTabPtr.p->m_bits |= (gcpIndicator ? Tablerec::TR_RowGCI : 0);
+
+ regTabPtr.p->m_offsets[MM].m_disk_ref_offset= 0;
+ regTabPtr.p->m_offsets[MM].m_null_words= 0;
+ regTabPtr.p->m_offsets[MM].m_varpart_offset= 0;
+ regTabPtr.p->m_offsets[MM].m_max_var_offset= 0;
+
+ regTabPtr.p->m_offsets[DD].m_disk_ref_offset= 0;
+ regTabPtr.p->m_offsets[DD].m_null_words= 0;
+ regTabPtr.p->m_offsets[DD].m_varpart_offset= 0;
+ regTabPtr.p->m_offsets[DD].m_max_var_offset= 0;
+
+ regTabPtr.p->m_attributes[MM].m_no_of_fixsize= 0;
+ regTabPtr.p->m_attributes[MM].m_no_of_varsize= 0;
+ regTabPtr.p->m_attributes[DD].m_no_of_fixsize= 0;
+ regTabPtr.p->m_attributes[DD].m_no_of_varsize= 0;
+
+ regTabPtr.p->noOfKeyAttr= noOfKeyAttr;
+ regTabPtr.p->noOfCharsets= noOfCharsets;
+ regTabPtr.p->m_no_of_attributes= noOfAttributes;
+
regTabPtr.p->notNullAttributeMask.clear();
-
+ regTabPtr.p->blobAttributeMask.clear();
+
Uint32 offset[10];
- Uint32 tableDescriptorRef = allocTabDescr(regTabPtr.p, offset);
+ Uint32 tableDescriptorRef= allocTabDescr(regTabPtr.p, offset);
if (tableDescriptorRef == RNIL) {
ljam();
fragrefuse4Lab(signal, fragOperPtr, regFragPtr, regTabPtr.p, fragId);
return;
- }//if
+ }
setUpDescriptorReferences(tableDescriptorRef, regTabPtr.p, offset);
} 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;
+ fragOperPtr.p->definingFragment= false;
+ }
+ 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)
+bool Dbtup::addfragtotab(Tablerec* const regTabPtr,
+ Uint32 fragId,
+ Uint32 fragIndex)
{
- for (Uint32 i = 0; i < (2 * MAX_FRAG_PER_NODE); i++) {
+ for (Uint32 i = 0; i < MAX_FRAG_PER_NODE; i++) {
ljam();
if (regTabPtr->fragid[i] == RNIL) {
ljam();
- regTabPtr->fragid[i] = fragId;
- regTabPtr->fragrec[i] = fragIndex;
+ 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)
+void Dbtup::getFragmentrec(FragrecordPtr& regFragPtr,
+ Uint32 fragId,
+ Tablerec* const regTabPtr)
{
- for (Uint32 i = 0; i < (2 * MAX_FRAG_PER_NODE); i++) {
+ for (Uint32 i = 0; i < MAX_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];
+ regFragPtr.i= regTabPtr->fragrec[i];
ptrCheckGuard(regFragPtr, cnoOfFragrec, fragrecord);
return;
- }//if
- }//for
- regFragPtr.i = RNIL;
+ }
+ }
+ regFragPtr.i= RNIL;
ptrNull(regFragPtr);
-}//Dbtup::getFragmentrec()
+}
void Dbtup::seizeFragrecord(FragrecordPtr& regFragPtr)
{
- regFragPtr.i = cfirstfreefrag;
+ regFragPtr.i= cfirstfreefrag;
ptrCheckGuard(regFragPtr, cnoOfFragrec, fragrecord);
- cfirstfreefrag = regFragPtr.p->nextfreefrag;
- regFragPtr.p->nextfreefrag = RNIL;
-}//Dbtup::seizeFragrecord()
-
-/* ---------------------------------------------------------------- */
-/* SEIZE A FRAGMENT OPERATION RECORD */
-/* ---------------------------------------------------------------- */
+ cfirstfreefrag= regFragPtr.p->nextfreefrag;
+ regFragPtr.p->nextfreefrag= RNIL;
+}
+
void Dbtup::seizeFragoperrec(FragoperrecPtr& fragOperPtr)
{
- fragOperPtr.i = cfirstfreeFragopr;
+ fragOperPtr.i= cfirstfreeFragopr;
ptrCheckGuard(fragOperPtr, cnoOfFragoprec, fragoperrec);
cfirstfreeFragopr = fragOperPtr.p->nextFragoprec;
fragOperPtr.p->nextFragoprec = RNIL;
@@ -282,17 +279,18 @@
TablerecPtr regTabPtr;
ljamEntry();
- fragOperPtr.i = signal->theData[0];
+ fragOperPtr.i= signal->theData[0];
ptrCheckGuard(fragOperPtr, cnoOfFragoprec, fragoperrec);
Uint32 attrId = signal->theData[2];
Uint32 attrDescriptor = signal->theData[3];
+ Uint32 extType = AttributeDescriptor::getType(attrDescriptor);
// DICT sends charset number in upper half
Uint32 csNumber = (signal->theData[4] >> 16);
- regTabPtr.i = fragOperPtr.p->tableidFrag;
+ regTabPtr.i= fragOperPtr.p->tableidFrag;
ptrCheckGuard(regTabPtr, cnoOfTablerec, tablerec);
- Uint32 fragId = fragOperPtr.p->fragidFrag;
+ Uint32 fragId= fragOperPtr.p->fragidFrag;
getFragmentrec(regFragPtr, fragId, regTabPtr.p);
ndbrequire(regFragPtr.i != RNIL);
@@ -301,103 +299,118 @@
fragOperPtr.p->attributeCount--;
const bool lastAttr = (fragOperPtr.p->attributeCount == 0);
- if ((regTabPtr.p->tableStatus == DEFINING) &&
- (fragOperPtr.p->definingFragment)) {
+ if (regTabPtr.p->tableStatus != DEFINING)
+ {
+ ndbrequire(regTabPtr.p->tableStatus == DEFINED);
+ signal->theData[0] = fragOperPtr.p->lqhPtrFrag;
+ signal->theData[1] = lastAttr;
+ sendSignal(fragOperPtr.p->lqhBlockrefFrag, GSN_TUP_ADD_ATTCONF,
+ signal, 2, JBB);
+
+ if(lastAttr)
+ {
+ /**
+ * Init Disk_alloc_info
+ */
+ CreateFilegroupImplReq rep;
+ if(regTabPtr.p->m_no_of_disk_attributes)
+ {
+ Tablespace_client tsman(0, c_tsman, 0, 0,
+ regFragPtr.p->m_tablespace_id);
+ ndbrequire(tsman.get_tablespace_info(&rep) == 0);
+ regFragPtr.p->m_logfile_group_id= rep.tablespace.logfile_group_id;
+ }
+ new (®FragPtr.p->m_disk_alloc_info)
+ Disk_alloc_info(regTabPtr.p, rep.tablespace.extent_size);
+ releaseFragoperrec(fragOperPtr);
+ }
+ return;
+ }
+
+ Uint32 firstTabDesIndex= regTabPtr.p->tabDescriptor + (attrId * ZAD_SIZE);
+ setTabDescrWord(firstTabDesIndex, attrDescriptor);
+ Uint32 attrLen = AttributeDescriptor::getSize(attrDescriptor);
+
+ Uint32 attrDes2= 0;
+ if (!AttributeDescriptor::getDynamic(attrDescriptor)) {
ljam();
- Uint32 firstTabDesIndex = regTabPtr.p->tabDescriptor + (attrId * ZAD_SIZE);
- setTabDescrWord(firstTabDesIndex, attrDescriptor);
- Uint32 attrLen = AttributeDescriptor::getSize(attrDescriptor);
- Uint32 nullBitPos = fragOperPtr.p->currNullBit;
- Uint32 bitCount = 0;
-
- if (AttributeDescriptor::getNullable(attrDescriptor)) {
- if (!AttributeDescriptor::getDynamic(attrDescriptor)) {
- ljam(); /* NULL ATTR */
- fragOperPtr.p->currNullBit++;
- }//if
- } else {
+ Uint32 pos= 0, null_pos;
+ Uint32 bytes= AttributeDescriptor::getSizeInBytes(attrDescriptor);
+ Uint32 words= (bytes + 3) / 4;
+ Uint32 ind= AttributeDescriptor::getDiskBased(attrDescriptor);
+ ndbrequire(ind <= 1);
+ null_pos= fragOperPtr.p->m_null_bits[ind];
+
+ if (AttributeDescriptor::getNullable(attrDescriptor))
+ {
ljam();
+ fragOperPtr.p->m_null_bits[ind]++;
+ }
+ else
+ {
regTabPtr.p->notNullAttributeMask.set(attrId);
- }//if
+ }
+
+ if (extType == NDB_TYPE_BLOB || extType == NDB_TYPE_TEXT) {
+ regTabPtr.p->blobAttributeMask.set(attrId);
+ }
- Uint32 attrDes2 = 0;
- if (!AttributeDescriptor::getDynamic(attrDescriptor)) {
+ switch (AttributeDescriptor::getArrayType(attrDescriptor)) {
+ case NDB_ARRAYTYPE_FIXED:
+ {
ljam();
- Uint32 attributePos = regTabPtr.p->tupheadsize;
- switch (AttributeDescriptor::getArrayType(attrDescriptor)) {
- case 1:
- case 2:
+ regTabPtr.p->m_attributes[ind].m_no_of_fixsize++;
+ if(attrLen != 0)
{
- ljam();
- if(attrLen != 0)
- {
- ljam();
- Uint32 bitsUsed =
- AttributeDescriptor::getArraySize(attrDescriptor) * (1 << attrLen);
- regTabPtr.p->tupheadsize += ((bitsUsed + 31) >> 5);
- break;
- }
- else
- {
- ljam();
- bitCount = AttributeDescriptor::getArraySize(attrDescriptor);
- fragOperPtr.p->currNullBit += bitCount;
- break;
- }
+ ljam();
+ pos= fragOperPtr.p->m_fix_attributes_size[ind];
+ fragOperPtr.p->m_fix_attributes_size[ind] += words;
}
- default:
- ndbrequire(false);
- break;
- }//switch
- if(nullBitPos + bitCount + 1 >= MAX_NULL_BITS)
+ else
{
- terrorCode = TupAddAttrRef::TooManyBitsUsed;
- addattrrefuseLab(signal, regFragPtr, fragOperPtr, regTabPtr.p, fragId);
- return;
- }
- AttributeOffset::setOffset(attrDes2, attributePos);
- AttributeOffset::setNullFlagPos(attrDes2, nullBitPos);
- } else {
- ndbrequire(false);
- }//if
- if (csNumber != 0) {
- CHARSET_INFO* cs = all_charsets[csNumber];
- ndbrequire(cs != NULL);
- Uint32 i = 0;
- while (i < fragOperPtr.p->charsetIndex) {
- ljam();
- if (regTabPtr.p->charsetArray[i] == cs)
- break;
- i++;
- }
- if (i == fragOperPtr.p->charsetIndex) {
- ljam();
- fragOperPtr.p->charsetIndex++;
+ ljam();
+ Uint32 bitCount = AttributeDescriptor::getArraySize(attrDescriptor);
+ fragOperPtr.p->m_null_bits[ind] += bitCount;
}
- ndbrequire(i < regTabPtr.p->noOfCharsets);
- regTabPtr.p->charsetArray[i] = cs;
- AttributeOffset::setCharsetPos(attrDes2, i);
+ break;
}
- 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 (lastAttr &&
- (fragOperPtr.p->currNullBit != fragOperPtr.p->noOfNullBits))
+ default:
{
ljam();
- terrorCode = ZINCONSISTENT_NULL_ATTRIBUTE_COUNT;
- addattrrefuseLab(signal, regFragPtr, fragOperPtr, regTabPtr.p, fragId);
- return;
- }//if
- }//if
- if (ERROR_INSERTED(4009) && regTabPtr.p->fragid[0] == fragId && attrId == 0 ||
+ fragOperPtr.p->m_var_attributes_size[ind] += bytes;
+ pos= regTabPtr.p->m_attributes[ind].m_no_of_varsize++;
+ break;
+ }
+ }//switch
+
+ AttributeOffset::setOffset(attrDes2, pos);
+ AttributeOffset::setNullFlagPos(attrDes2, null_pos);
+ } else {
+ ndbrequire(false);
+ }
+ if (csNumber != 0) {
+ CHARSET_INFO* cs = all_charsets[csNumber];
+ ndbrequire(cs != NULL);
+ Uint32 i = 0;
+ while (i < fragOperPtr.p->charsetIndex) {
+ ljam();
+ if (regTabPtr.p->charsetArray[i] == cs)
+ break;
+ i++;
+ }
+ if (i == fragOperPtr.p->charsetIndex) {
+ ljam();
+ fragOperPtr.p->charsetIndex++;
+ }
+ ndbrequire(i < regTabPtr.p->noOfCharsets);
+ regTabPtr.p->charsetArray[i]= cs;
+ AttributeOffset::setCharsetPos(attrDes2, i);
+ }
+ setTabDescrWord(firstTabDesIndex + 1, attrDes2);
+
+ if (ERROR_INSERTED(4009) && regTabPtr.p->fragid[0] == fragId && attrId == 0||
ERROR_INSERTED(4010) && regTabPtr.p->fragid[0] == fragId && lastAttr ||
- ERROR_INSERTED(4011) && regTabPtr.p->fragid[1] == fragId && attrId == 0 ||
+ ERROR_INSERTED(4011) && regTabPtr.p->fragid[1] == fragId && attrId == 0||
ERROR_INSERTED(4012) && regTabPtr.p->fragid[1] == fragId && lastAttr) {
ljam();
terrorCode = 1;
@@ -406,10 +419,127 @@
return;
}
- if (lastAttr)
- {
+/* **************************************************************** */
+/* ************** TUP_ADD_ATTCONF ****************** */
+/* **************************************************************** */
+ if (! lastAttr) {
ljam();
- Uint32 noRowsPerPage = ZWORDS_ON_PAGE/regTabPtr.p->tupheadsize;
+ signal->theData[0] = fragOperPtr.p->lqhPtrFrag;
+ signal->theData[1] = lastAttr;
+ sendSignal(fragOperPtr.p->lqhBlockrefFrag, GSN_TUP_ADD_ATTCONF,
+ signal, 2, JBB);
+ return;
+ }
+
+ ndbrequire(regTabPtr.p->tableStatus == DEFINING);
+ regTabPtr.p->tableStatus= DEFINED;
+ regFragPtr.p->fragStatus= ACTIVE;
+
+#define BTW(x) ((x+31) >> 5)
+ regTabPtr.p->m_offsets[MM].m_null_words= BTW(fragOperPtr.p->m_null_bits[MM]);
+ regTabPtr.p->m_offsets[DD].m_null_words= BTW(fragOperPtr.p->m_null_bits[DD]);
+
+ /**
+ * Fix offsets
+ */
+ Uint32 pos[2] = { 0, 0 };
+ if (regTabPtr.p->m_bits & Tablerec::TR_Checksum)
+ {
+ pos[0]= 1;
+ }
+
+ if (regTabPtr.p->m_bits & Tablerec::TR_RowGCI)
+ {
+ pos[MM]++;
+ pos[DD]++;
+ }
+
+ regTabPtr.p->m_no_of_disk_attributes=
+ regTabPtr.p->m_attributes[DD].m_no_of_fixsize +
+ regTabPtr.p->m_attributes[DD].m_no_of_varsize;
+
+ if(regTabPtr.p->m_no_of_disk_attributes > 0)
+ {
+ regTabPtr.p->m_offsets[MM].m_disk_ref_offset= pos[MM];
+ pos[MM] += 2; // 8 bytes
+ }
+
+ regTabPtr.p->m_offsets[MM].m_null_offset= pos[MM];
+ regTabPtr.p->m_offsets[DD].m_null_offset= pos[DD];
+
+ pos[MM]+= regTabPtr.p->m_offsets[MM].m_null_words;
+ pos[DD]+= regTabPtr.p->m_offsets[DD].m_null_words;
+
+ Uint32 *tabDesc = (Uint32*)(tableDescriptor+regTabPtr.p->tabDescriptor);
+ for(Uint32 i= 0; i<regTabPtr.p->m_no_of_attributes; i++)
+ {
+ Uint32 ind= AttributeDescriptor::getDiskBased(* tabDesc);
+ Uint32 arr= AttributeDescriptor::getArrayType(* tabDesc++);
+
+ if(arr == NDB_ARRAYTYPE_FIXED)
+ {
+ Uint32 desc= * tabDesc;
+ Uint32 off= AttributeOffset::getOffset(desc) + pos[ind];
+ AttributeOffset::setOffset(desc, off);
+ * tabDesc= desc;
+ }
+ tabDesc++;
+ }
+
+ regTabPtr.p->m_offsets[MM].m_fix_header_size=
+ fragOperPtr.p->m_fix_attributes_size[MM] +
+ pos[MM];
+
+ regTabPtr.p->m_offsets[DD].m_fix_header_size=
+ fragOperPtr.p->m_fix_attributes_size[DD] +
+ pos[DD];
+
+ if(regTabPtr.p->m_attributes[MM].m_no_of_varsize == 0)
+ regTabPtr.p->m_offsets[MM].m_fix_header_size += Tuple_header::HeaderSize;
+
+ if(regTabPtr.p->m_attributes[DD].m_no_of_varsize == 0 &&
+ regTabPtr.p->m_attributes[DD].m_no_of_fixsize > 0)
+ regTabPtr.p->m_offsets[DD].m_fix_header_size += Tuple_header::HeaderSize;
+
+ regTabPtr.p->m_offsets[MM].m_max_var_offset=
+ fragOperPtr.p->m_var_attributes_size[MM];
+
+ regTabPtr.p->m_offsets[DD].m_max_var_offset=
+ fragOperPtr.p->m_var_attributes_size[DD];
+
+ regTabPtr.p->total_rec_size=
+ pos[MM] + fragOperPtr.p->m_fix_attributes_size[MM] +
+ pos[DD] + fragOperPtr.p->m_fix_attributes_size[DD] +
+ ((fragOperPtr.p->m_var_attributes_size[MM] + 3) >> 2) +
+ ((fragOperPtr.p->m_var_attributes_size[DD] + 3) >> 2) +
+ (regTabPtr.p->m_attributes[MM].m_no_of_varsize ?
+ (regTabPtr.p->m_attributes[MM].m_no_of_varsize + 2) >> 1 : 0) +
+ (regTabPtr.p->m_attributes[DD].m_no_of_varsize ?
+ (regTabPtr.p->m_attributes[DD].m_no_of_varsize + 2) >> 1 : 0) +
+ Tuple_header::HeaderSize +
+ (regTabPtr.p->m_no_of_disk_attributes ? Tuple_header::HeaderSize : 0);
+
+ setUpQueryRoutines(regTabPtr.p);
+ setUpKeyArray(regTabPtr.p);
+
+#if 0
+ ndbout << *regTabPtr.p << endl;
+ Uint32 idx= regTabPtr.p->tabDescriptor;
+ for(Uint32 i = 0; i<regTabPtr.p->m_no_of_attributes; i++)
+ {
+ ndbout << i << ": " << endl;
+ ndbout << *(AttributeDescriptor*)(tableDescriptor+idx) << endl;
+ ndbout << *(AttributeOffset*)(tableDescriptor+idx+1) << endl;
+ idx += 2;
+ }
+#endif
+
+ {
+ Uint32 fix_tupheader = regTabPtr.p->m_offsets[MM].m_fix_header_size;
+ if(regTabPtr.p->m_attributes[MM].m_no_of_varsize != 0)
+ fix_tupheader += Tuple_header::HeaderSize + 1;
+ ndbassert(fix_tupheader > 0);
+ Uint32 noRowsPerPage = ZWORDS_ON_PAGE / fix_tupheader;
Uint32 noAllocatedPages =
(fragOperPtr.p->minRows + noRowsPerPage - 1 )/ noRowsPerPage;
if (fragOperPtr.p->minRows == 0)
@@ -426,26 +556,120 @@
}//if
}
-/* **************************************************************** */
-/* ************** TUP_ADD_ATTCONF ****************** */
-/* **************************************************************** */
+ CreateFilegroupImplReq rep;
+ if(regTabPtr.p->m_no_of_disk_attributes)
+ {
+ ljam();
+ Tablespace_client tsman(0, c_tsman, 0, 0,
+ regFragPtr.p->m_tablespace_id);
+ ndbrequire(tsman.get_tablespace_info(&rep) == 0);
+ regFragPtr.p->m_logfile_group_id= rep.tablespace.logfile_group_id;
+ }
+
+ new (®FragPtr.p->m_disk_alloc_info)
+ Disk_alloc_info(regTabPtr.p, rep.tablespace.extent_size);
+
+ if (regTabPtr.p->m_no_of_disk_attributes)
+ {
+ ljam();
+ if(!(getNodeState().startLevel == NodeState::SL_STARTING &&
+ getNodeState().starting.startPhase <= 4))
+ {
+ Callback cb;
+ ljam();
+
+ cb.m_callbackData= fragOperPtr.i;
+ cb.m_callbackFunction =
+ safe_cast(&Dbtup::undo_createtable_callback);
+ Uint32 sz= sizeof(Disk_undo::Create) >> 2;
+
+ Logfile_client lgman(this, c_lgman, regFragPtr.p->m_logfile_group_id);
+ int r0 = c_lgman->alloc_log_space(regFragPtr.p->m_logfile_group_id,
+ sz);
+
+ int res= lgman.get_log_buffer(signal, sz, &cb);
+ switch(res){
+ case 0:
+ ljam();
+ signal->theData[0] = 1;
+ return;
+ case -1:
+ ndbrequire("NOT YET IMPLEMENTED" == 0);
+ break;
+ }
+ execute(signal, cb, 0);
+ return;
+ }
+ }
+
signal->theData[0] = fragOperPtr.p->lqhPtrFrag;
signal->theData[1] = lastAttr;
- sendSignal(fragOperPtr.p->lqhBlockrefFrag, GSN_TUP_ADD_ATTCONF, signal, 2, JBB);
- if (! lastAttr) {
- 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
+ sendSignal(fragOperPtr.p->lqhBlockrefFrag, GSN_TUP_ADD_ATTCONF,
+ signal, 2, JBB);
+
releaseFragoperrec(fragOperPtr);
+
return;
-}//Dbtup::execTUP_ADD_ATTRREQ()
+}
+
+void
+Dbtup::undo_createtable_callback(Signal* signal, Uint32 opPtrI, Uint32 unused)
+{
+ FragrecordPtr regFragPtr;
+ FragoperrecPtr fragOperPtr;
+ TablerecPtr regTabPtr;
+
+ fragOperPtr.i= opPtrI;
+ ptrCheckGuard(fragOperPtr, cnoOfFragoprec, fragoperrec);
+
+ regTabPtr.i= fragOperPtr.p->tableidFrag;
+ ptrCheckGuard(regTabPtr, cnoOfTablerec, tablerec);
+
+ getFragmentrec(regFragPtr, fragOperPtr.p->fragidFrag, regTabPtr.p);
+ ndbrequire(regFragPtr.i != RNIL);
+
+ Logfile_client lgman(this, c_lgman, regFragPtr.p->m_logfile_group_id);
+
+ Disk_undo::Create create;
+ create.m_type_length= Disk_undo::UNDO_CREATE << 16 | (sizeof(create) >> 2);
+ create.m_table = regTabPtr.i;
+
+ Logfile_client::Change c[1] = {{ &create, sizeof(create) >> 2 } };
+
+ Uint64 lsn= lgman.add_entry(c, 1);
+
+ Logfile_client::Request req;
+ req.m_callback.m_callbackData= fragOperPtr.i;
+ req.m_callback.m_callbackFunction =
+ safe_cast(&Dbtup::undo_createtable_logsync_callback);
+
+ int ret = lgman.sync_lsn(signal, lsn, &req, 0);
+ switch(ret){
+ case 0:
+ return;
+ default:
+ ndbout_c("ret: %d", ret);
+ ndbrequire(false);
+ }
+
+}
+
+void
+Dbtup::undo_createtable_logsync_callback(Signal* signal, Uint32 ptrI,
+ Uint32 res)
+{
+ jamEntry();
+ FragoperrecPtr fragOperPtr;
+ fragOperPtr.i= ptrI;
+ ptrCheckGuard(fragOperPtr, cnoOfFragoprec, fragoperrec);
+
+ signal->theData[0] = fragOperPtr.p->lqhPtrFrag;
+ signal->theData[1] = 1;
+ sendSignal(fragOperPtr.p->lqhBlockrefFrag, GSN_TUP_ADD_ATTCONF,
+ signal, 2, JBB);
+
+ releaseFragoperrec(fragOperPtr);
+}
/*
* Descriptor has these parts:
@@ -454,49 +678,84 @@
* 1 updateFunctionArray ( ditto )
* 2 charsetArray ( pointers to distinct CHARSET_INFO )
* 3 readKeyArray ( attribute ids of keys )
- * 4 attributeGroupDescriptor ( currently size 1 but unused )
* 5 tabDescriptor ( attribute descriptors, each ZAD_SIZE )
*/
-
void Dbtup::setUpDescriptorReferences(Uint32 descriptorReference,
Tablerec* const regTabPtr,
const Uint32* offset)
{
- Uint32* desc = &tableDescriptor[descriptorReference].tabDescr;
- regTabPtr->readFunctionArray = (ReadFunction*)(desc + offset[0]);
- regTabPtr->updateFunctionArray = (UpdateFunction*)(desc + offset[1]);
- regTabPtr->charsetArray = (CHARSET_INFO**)(desc + offset[2]);
- regTabPtr->readKeyArray = descriptorReference + offset[3];
- regTabPtr->attributeGroupDescriptor = descriptorReference + offset[4];
- regTabPtr->tabDescriptor = descriptorReference + offset[5];
-}//Dbtup::setUpDescriptorReferences()
+ Uint32* desc= &tableDescriptor[descriptorReference].tabDescr;
+ regTabPtr->readFunctionArray= (ReadFunction*)(desc + offset[0]);
+ regTabPtr->updateFunctionArray= (UpdateFunction*)(desc + offset[1]);
+ regTabPtr->charsetArray= (CHARSET_INFO**)(desc + offset[2]);
+ regTabPtr->readKeyArray= descriptorReference + offset[3];
+ regTabPtr->tabDescriptor= descriptorReference + offset[4];
+ regTabPtr->m_real_order_descriptor = descriptorReference + offset[5];
+}
Uint32
Dbtup::sizeOfReadFunction()
{
- ReadFunction* tmp = (ReadFunction*)&tableDescriptor[0];
- TableDescriptor* start = &tableDescriptor[0];
- TableDescriptor * end = (TableDescriptor*)(tmp + 1);
+ 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++) {
+ ndbrequire((regTabPtr->readKeyArray + regTabPtr->noOfKeyAttr) <
+ cnoOfTabDescrRec);
+ Uint32* keyArray= &tableDescriptor[regTabPtr->readKeyArray].tabDescr;
+ Uint32 countKeyAttr= 0;
+ for (Uint32 i= 0; i < regTabPtr->m_no_of_attributes; i++) {
ljam();
- Uint32 refAttr = regTabPtr->tabDescriptor + (i * ZAD_SIZE);
- Uint32 attrDescriptor = getTabDescrWord(refAttr);
+ 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()
+
+ /**
+ * Setup real order array (16 bit per column)
+ */
+ const Uint32 off= regTabPtr->m_real_order_descriptor;
+ const Uint32 sz= (regTabPtr->m_no_of_attributes + 1) >> 1;
+ ndbrequire((off + sz) < cnoOfTabDescrRec);
+
+ Uint32 cnt= 0;
+ Uint16* order= (Uint16*)&tableDescriptor[off].tabDescr;
+ for (Uint32 type = 0; type < 4; type++)
+ {
+ for (Uint32 i= 0; i < regTabPtr->m_no_of_attributes; i++)
+ {
+ ljam();
+ Uint32 refAttr= regTabPtr->tabDescriptor + (i * ZAD_SIZE);
+ Uint32 desc = getTabDescrWord(refAttr);
+ Uint32 t = 0;
+
+ if (AttributeDescriptor::getArrayType(desc) != NDB_ARRAYTYPE_FIXED)
+ {
+ t += 1;
+ }
+ if (AttributeDescriptor::getDiskBased(desc))
+ {
+ t += 2;
+ }
+ ndbrequire(t < 4);
+ if(t == type)
+ {
+ * order++ = i << ZAD_LOG_SIZE;
+ cnt++;
+ }
+ }
+ }
+ ndbrequire(cnt == regTabPtr->m_no_of_attributes);
+}
void Dbtup::addattrrefuseLab(Signal* signal,
FragrecordPtr regFragPtr,
@@ -510,12 +769,12 @@
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);
+ 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,
@@ -526,8 +785,7 @@
releaseFragPages(regFragPtr.p);
fragrefuse3Lab(signal, fragOperPtr, regFragPtr, regTabPtr, fragId);
initTab(regTabPtr);
- return;
-}//Dbtup::fragrefuse4Lab()
+}
void Dbtup::fragrefuse3Lab(Signal* signal,
FragoperrecPtr fragOperPtr,
@@ -537,30 +795,28 @@
{
fragrefuse2Lab(signal, fragOperPtr, regFragPtr);
deleteFragTab(regTabPtr, fragId);
- return;
-}//Dbtup::fragrefuse3Lab()
+}
-void Dbtup::fragrefuse2Lab(Signal* signal, FragoperrecPtr fragOperPtr, FragrecordPtr regFragPtr)
+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;
+ 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)
{
@@ -571,17 +827,17 @@
void Dbtup::deleteFragTab(Tablerec* const regTabPtr, Uint32 fragId)
{
- for (Uint32 i = 0; i < (2 * MAX_FRAG_PER_NODE); i++) {
+ for (Uint32 i = 0; i < MAX_FRAG_PER_NODE; i++) {
ljam();
if (regTabPtr->fragid[i] == fragId) {
ljam();
- regTabPtr->fragid[i] = RNIL;
- regTabPtr->fragrec[i] = RNIL;
+ regTabPtr->fragid[i]= RNIL;
+ regTabPtr->fragrec[i]= RNIL;
return;
- }//if
- }//for
+ }
+ }
ndbrequire(false);
-}//Dbtup::deleteFragTab()
+}
/*
* LQH aborts on-going create table operation. The table is later
@@ -606,129 +862,323 @@
verifytabdes();
#endif
}
- DropTabReq* req = (DropTabReq*)signal->getDataPtr();
+ DropTabReq* req= (DropTabReq*)signal->getDataPtr();
TablerecPtr tabPtr;
- tabPtr.i = req->tableId;
+ tabPtr.i= req->tableId;
ptrCheckGuard(tabPtr, cnoOfTablerec, tablerec);
tabPtr.p->m_dropTable.tabUserRef = req->senderRef;
tabPtr.p->m_dropTable.tabUserPtr = req->senderData;
+ tabPtr.p->tableStatus = DROPPING;
- signal->theData[0] = ZREL_FRAG;
- signal->theData[1] = tabPtr.i;
+ 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;
+ Uint32 descriptor= regTabPtr->readKeyArray;
if (descriptor != RNIL) {
ljam();
Uint32 offset[10];
getTabDescrOffsets(regTabPtr, offset);
- regTabPtr->tabDescriptor = RNIL;
- regTabPtr->readKeyArray = RNIL;
- regTabPtr->readFunctionArray = NULL;
- regTabPtr->updateFunctionArray = NULL;
- regTabPtr->charsetArray = NULL;
- regTabPtr->attributeGroupDescriptor= RNIL;
+ regTabPtr->tabDescriptor= RNIL;
+ regTabPtr->readKeyArray= RNIL;
+ regTabPtr->readFunctionArray= NULL;
+ regTabPtr->updateFunctionArray= NULL;
+ regTabPtr->charsetArray= NULL;
// move to start of descriptor
descriptor -= offset[3];
- Uint32 retNo = getTabDescrWord(descriptor + ZTD_DATASIZE);
+ 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));
+ 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;
+ tabPtr.i= tableId;
ptrCheckGuard(tabPtr, cnoOfTablerec, tablerec);
Uint32 fragIndex = RNIL;
Uint32 fragId = RNIL;
Uint32 i = 0;
- for (i = 0; i < (2 * MAX_FRAG_PER_NODE); i++) {
+ for (i = 0; i < MAX_FRAG_PER_NODE; i++) {
ljam();
if (tabPtr.p->fragid[i] != RNIL) {
ljam();
- fragIndex = tabPtr.p->fragrec[i];
- fragId = tabPtr.p->fragid[i];
+ 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);
+ signal->theData[0] = ZUNMAP_PAGES;
+ signal->theData[1] = tabPtr.i;
+ signal->theData[2] = fragIndex;
+ signal->theData[3] = 0;
+ sendSignal(cownref, GSN_CONTINUEB, signal, 4, JBB);
return;
- }//if
+ }
- /**
- * Finished...
- */
- sendFSREMOVEREQ(signal, tabPtr);
-}//Dbtup::releaseFragment()
+ 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);
+}
-void Dbtup::sendFSREMOVEREQ(Signal* signal, TablerecPtr tabPtr)
+void
+Dbtup::drop_fragment_unmap_pages(Signal *signal,
+ TablerecPtr tabPtr,
+ FragrecordPtr fragPtr,
+ Uint32 pos)
{
- 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)
+ if (tabPtr.p->m_no_of_disk_attributes)
+ {
+ Disk_alloc_info& alloc_info= fragPtr.p->m_disk_alloc_info;
+ while(alloc_info.m_dirty_pages[pos].isEmpty() && pos < MAX_FREE_LIST)
+ pos++;
+
+ if (pos == MAX_FREE_LIST)
+ {
+ if(alloc_info.m_curr_extent_info_ptr_i != RNIL)
+ {
+ Local_extent_info_list
+ list(c_extent_pool, alloc_info.m_free_extents[0]);
+ Ptr<Extent_info> ext_ptr;
+ c_extent_pool.getPtr(ext_ptr, alloc_info.m_curr_extent_info_ptr_i);
+ list.add(ext_ptr);
+ alloc_info.m_curr_extent_info_ptr_i= RNIL;
+ }
+
+ drop_fragment_free_exent(signal, tabPtr, fragPtr, 0);
+ return;
+ }
+
+ Ptr<Page> pagePtr;
+ ArrayPool<Page> *pool= (ArrayPool<Page>*)&m_global_page_pool;
+ {
+ LocalDLList<Page> list(*pool, alloc_info.m_dirty_pages[pos]);
+ list.first(pagePtr);
+ list.remove(pagePtr);
+ }
+
+ Page_cache_client::Request req;
+ req.m_page.m_page_no = pagePtr.p->m_page_no;
+ req.m_page.m_file_no = pagePtr.p->m_file_no;
+
+ req.m_callback.m_callbackData= pos;
+ req.m_callback.m_callbackFunction =
+ safe_cast(&Dbtup::drop_fragment_unmap_page_callback);
+
+ int flags= Page_cache_client::COMMIT_REQ;
+ int res= m_pgman.get_page(signal, req, flags);
+ switch(res)
+ {
+ case 0:
+ case -1:
+ break;
+ default:
+ ndbrequire((Uint32)res == pagePtr.i);
+ drop_fragment_unmap_page_callback(signal, pos, res);
+ }
+ return;
+ }
+ drop_fragment_free_exent(signal, tabPtr, fragPtr, 0);
+}
+
+void
+Dbtup::drop_fragment_unmap_page_callback(Signal* signal,
+ Uint32 pos, Uint32 page_id)
{
- ljamEntry();
+ Ptr<GlobalPage> page;
+ m_global_page_pool.getPtr(page, page_id);
- FsConf * const fsConf = (FsConf *)signal->getDataPtrSend();
+ Local_key key;
+ key.m_page_no = ((Page*)page.p)->m_page_no;
+ key.m_file_no = ((Page*)page.p)->m_file_no;
+
+ Uint32 fragId = ((Page*)page.p)->m_fragment_id;
+ Uint32 tableId = ((Page*)page.p)->m_table_id;
+ m_pgman.drop_page(key, page_id);
+
TablerecPtr tabPtr;
- tabPtr.i = fsConf->userPointer;
+ tabPtr.i= tableId;
ptrCheckGuard(tabPtr, cnoOfTablerec, tablerec);
+
+ FragrecordPtr fragPtr;
+ getFragmentrec(fragPtr, fragId, tabPtr.p);
+
+ signal->theData[0] = ZUNMAP_PAGES;
+ signal->theData[1] = tabPtr.i;
+ signal->theData[2] = fragPtr.i;
+ signal->theData[3] = pos;
+ sendSignal(cownref, GSN_CONTINUEB, signal, 4, JBB);
+}
+void
+Dbtup::drop_fragment_free_exent(Signal *signal,
+ TablerecPtr tabPtr,
+ FragrecordPtr fragPtr,
+ Uint32 pos)
+{
+ if (tabPtr.p->m_no_of_disk_attributes)
+ {
+ Disk_alloc_info& alloc_info= fragPtr.p->m_disk_alloc_info;
+ for(; pos<EXTENT_SEARCH_MATRIX_SIZE; pos++)
+ {
+ if(!alloc_info.m_free_extents[pos].isEmpty())
+ {
+ jam();
+ Local_extent_info_list
+ list(c_extent_pool, alloc_info.m_free_extents[pos]);
+ Ptr<Extent_info> ext_ptr;
+ list.first(ext_ptr);
+
+ Tablespace_client tsman(signal, c_tsman, tabPtr.i,
+ fragPtr.p->fragmentId,
+ fragPtr.p->m_tablespace_id);
+
+ tsman.free_extent(&ext_ptr.p->m_key);
+ c_extent_hash.remove(ext_ptr);
+ list.release(ext_ptr);
+
+ signal->theData[0] = ZFREE_EXTENT;
+ signal->theData[1] = tabPtr.i;
+ signal->theData[2] = fragPtr.i;
+ signal->theData[3] = pos;
+ sendSignal(cownref, GSN_CONTINUEB, signal, 4, JBB);
+ return;
+ }
+ }
+
+ ArrayPool<Page> *cheat_pool= (ArrayPool<Page>*)&m_global_page_pool;
+ for(pos= 0; pos<MAX_FREE_LIST; pos++)
+ {
+ ndbrequire(alloc_info.m_page_requests[pos].isEmpty());
+ LocalDLList<Page> list(* cheat_pool, alloc_info.m_dirty_pages[pos]);
+ list.remove();
+ }
+ }
- 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);
+ signal->theData[0] = ZFREE_VAR_PAGES;
+ signal->theData[1] = tabPtr.i;
+ signal->theData[2] = fragPtr.i;
+ sendSignal(reference(), GSN_CONTINUEB, signal, 3, JBB);
+}
+
+void
+Dbtup::drop_fragment_free_var_pages(Signal* signal)
+{
+ ljam();
+ Uint32 tableId = signal->theData[1];
+ Uint32 fragPtrI = signal->theData[2];
- releaseTabDescr(tabPtr.p);
- initTab(tabPtr.p);
- if (ERROR_INSERTED(4013)) {
- CLEAR_ERROR_INSERT_VALUE;
-#ifdef VM_TRACE
- verifytabdes();
-#endif
+ TablerecPtr tabPtr;
+ tabPtr.i= tableId;
+ ptrCheckGuard(tabPtr, cnoOfTablerec, tablerec);
+
+ FragrecordPtr fragPtr;
+ fragPtr.i = fragPtrI;
+ ptrCheckGuard(fragPtr, cnoOfFragrec, fragrecord);
+
+ PagePtr pagePtr;
+ if ((pagePtr.i = fragPtr.p->m_var_page_chunks) != RNIL)
+ {
+ c_page_pool.getPtr(pagePtr);
+ Var_page* page = (Var_page*)pagePtr.p;
+ fragPtr.p->m_var_page_chunks = page->next_chunk;
+
+ Uint32 sz = page->chunk_size;
+ returnCommonArea(pagePtr.i, sz);
+
+ signal->theData[0] = ZFREE_VAR_PAGES;
+ signal->theData[1] = tabPtr.i;
+ signal->theData[2] = fragPtr.i;
+ sendSignal(cownref, GSN_CONTINUEB, signal, 3, JBB);
+ return;
}
-}//Dbtup::execFSREMOVECONF()
+
+ releaseFragPages(fragPtr.p);
+ Uint32 i;
+ for(i= 0; i<MAX_FRAG_PER_NODE; i++)
+ if(tabPtr.p->fragrec[i] == fragPtr.i)
+ break;
+
+ ndbrequire(i != MAX_FRAG_PER_NODE);
+ tabPtr.p->fragid[i]= RNIL;
+ tabPtr.p->fragrec[i]= RNIL;
+ releaseFragrec(fragPtr);
+
+ signal->theData[0]= ZREL_FRAG;
+ signal->theData[1]= tabPtr.i;
+ sendSignal(cownref, GSN_CONTINUEB, signal, 2, JBB);
+ return;
+}
+void
+Dbtup::start_restore_lcp(Uint32 tableId, Uint32 fragId)
+{
+ TablerecPtr tabPtr;
+ tabPtr.i= tableId;
+ ptrCheckGuard(tabPtr, cnoOfTablerec, tablerec);
+
+ tabPtr.p->m_dropTable.tabUserPtr= tabPtr.p->m_attributes[DD].m_no_of_fixsize;
+ tabPtr.p->m_dropTable.tabUserRef= tabPtr.p->m_attributes[DD].m_no_of_varsize;
+
+ Uint32 *tabDesc = (Uint32*)(tableDescriptor+tabPtr.p->tabDescriptor);
+ for(Uint32 i= 0; i<tabPtr.p->m_no_of_attributes; i++)
+ {
+ Uint32 disk= AttributeDescriptor::getDiskBased(* tabDesc);
+ Uint32 null= AttributeDescriptor::getNullable(* tabDesc);
+
+ ndbrequire(tabPtr.p->notNullAttributeMask.get(i) != null);
+ if(disk)
+ tabPtr.p->notNullAttributeMask.clear(i);
+ tabDesc += 2;
+ }
+
+ tabPtr.p->m_no_of_disk_attributes = 0;
+ tabPtr.p->m_attributes[DD].m_no_of_fixsize = 0;
+ tabPtr.p->m_attributes[DD].m_no_of_varsize = 0;
+}
+void
+Dbtup::complete_restore_lcp(Uint32 tableId, Uint32 fragId)
+{
+ TablerecPtr tabPtr;
+ tabPtr.i= tableId;
+ ptrCheckGuard(tabPtr, cnoOfTablerec, tablerec);
+
+ tabPtr.p->m_attributes[DD].m_no_of_fixsize= tabPtr.p->m_dropTable.tabUserPtr;
+ tabPtr.p->m_attributes[DD].m_no_of_varsize= tabPtr.p->m_dropTable.tabUserRef;
+
+ tabPtr.p->m_no_of_disk_attributes =
+ tabPtr.p->m_attributes[DD].m_no_of_fixsize +
+ tabPtr.p->m_attributes[DD].m_no_of_varsize;
+
+ Uint32 *tabDesc = (Uint32*)(tableDescriptor+tabPtr.p->tabDescriptor);
+ for(Uint32 i= 0; i<tabPtr.p->m_no_of_attributes; i++)
+ {
+ Uint32 disk= AttributeDescriptor::getDiskBased(* tabDesc);
+ Uint32 null= AttributeDescriptor::getNullable(* tabDesc);
+
+ if(disk && !null)
+ tabPtr.p->notNullAttributeMask.set(i);
+
+ tabDesc += 2;
+ }
+}
--- 1.2.1.2/ndb/src/kernel/blocks/dbtup/DbtupTabDesMan.cpp 2006-07-24 02:32:54 +10:00
+++ 1.5/storage/ndb/src/kernel/blocks/dbtup/DbtupTabDesMan.cpp 2006-07-24 02:32:54 +10:00
@@ -45,12 +45,12 @@
Uint32 allocSize = 0;
// magically aligned to 8 bytes
offset[0] = allocSize += ZTD_SIZE;
- offset[1] = allocSize += regTabPtr->noOfAttr * sizeOfReadFunction();
- offset[2] = allocSize += regTabPtr->noOfAttr * sizeOfReadFunction();
+ offset[1] = allocSize += regTabPtr->m_no_of_attributes* sizeOfReadFunction();
+ offset[2] = allocSize += regTabPtr->m_no_of_attributes* sizeOfReadFunction();
offset[3] = allocSize += regTabPtr->noOfCharsets * sizeOfPointer;
offset[4] = allocSize += regTabPtr->noOfKeyAttr;
- offset[5] = allocSize += regTabPtr->noOfAttributeGroups;
- allocSize += regTabPtr->noOfAttr * ZAD_SIZE;
+ offset[5] = allocSize += regTabPtr->m_no_of_attributes * ZAD_SIZE;
+ offset[6] = allocSize += (regTabPtr->m_no_of_attributes + 1) >> 1; // real order
allocSize += ZTD_TRAILER_SIZE;
// return number of words
return allocSize;
--- 1.20.6.1/ndb/test/ndbapi/testDict.cpp 2006-07-24 02:32:54 +10:00
+++ 1.30/storage/ndb/test/ndbapi/testDict.cpp 2006-07-24 02:32:54 +10:00
@@ -109,7 +109,7 @@
const NdbDictionary::Table* pTab = ctx->getTab();
// Try to create table in db
- if (pTab->createTableInDb(pNdb) != 0){
+ if (NDBT_Tables::createTable(pNdb, pTab->getName()) != 0){
return NDBT_FAILED;
}
@@ -151,7 +151,7 @@
}
// Try to create table in db
- if (pTab->createTableInDb(pNdb) == 0){
+ if (NDBT_Tables::createTable(pNdb, pTab->getName()) == 0){
result = NDBT_FAILED;
}
@@ -203,7 +203,7 @@
ndbout << i << ": ";
// Try to create table in db
- if (pTab->createTableInDb(pNdb) != 0){
+ if (NDBT_Tables::createTable(pNdb, pTab->getName()) != 0){
return NDBT_FAILED;
}
@@ -349,7 +349,8 @@
while (i < loops){
ndbout << i << ": ";
// Try to create table in db
- if (pTab->createTableInDb(pNdb) != 0){
+
+ if (NDBT_Tables::createTable(pNdb, pTab->getName()) != 0){
return NDBT_FAILED;
}
@@ -431,7 +432,7 @@
Ndb* pNdb = GETNDB(step);
g_debug << "Creating table" << endl;
- if (pTab->createTableInDb(pNdb) != 0){
+ if (NDBT_Tables::createTable(pNdb, pTab->getName()) != 0){
g_err << "createTableInDb failed" << endl;
result = NDBT_FAILED;
continue;
@@ -452,7 +453,6 @@
g_debug << "Dropping table" << endl;
-
if (pNdb->getDictionary()->dropTable(pTab2->getName()) != 0){
g_err << "Failed to drop "<<pTab2->getName()<<" in db" << endl;
result = NDBT_FAILED;
@@ -1568,6 +1568,99 @@
return NDBT_OK;
}
+int
+runCreateLogfileGroup(NDBT_Context* ctx, NDBT_Step* step){
+ Ndb* pNdb = GETNDB(step);
+ NdbDictionary::LogfileGroup lg;
+ lg.setName("DEFAULT-LG");
+ lg.setUndoBufferSize(8*1024*1024);
+
+ int res;
+ res = pNdb->getDictionary()->createLogfileGroup(lg);
+ if(res != 0){
+ g_err << "Failed to create logfilegroup:"
+ << endl << pNdb->getDictionary()->getNdbError() << endl;
+ return NDBT_FAILED;
+ }
+
+ NdbDictionary::Undofile uf;
+ uf.setPath("undofile01.dat");
+ uf.setSize(5*1024*1024);
+ uf.setLogfileGroup("DEFAULT-LG");
+
+ res = pNdb->getDictionary()->createUndofile(uf);
+ if(res != 0){
+ g_err << "Failed to create undofile:"
+ << endl << pNdb->getDictionary()->getNdbError() << endl;
+ return NDBT_FAILED;
+ }
+
+ uf.setPath("undofile02.dat");
+ uf.setSize(5*1024*1024);
+ uf.setLogfileGroup("DEFAULT-LG");
+
+ res = pNdb->getDictionary()->createUndofile(uf);
+ if(res != 0){
+ g_err << "Failed to create undofile:"
+ << endl << pNdb->getDictionary()->getNdbError() << endl;
+ return NDBT_FAILED;
+ }
+
+ return NDBT_OK;
+}
+
+int
+runCreateTablespace(NDBT_Context* ctx, NDBT_Step* step){
+ Ndb* pNdb = GETNDB(step);
+ NdbDictionary::Tablespace lg;
+ lg.setName("DEFAULT-TS");
+ lg.setExtentSize(1024*1024);
+ lg.setDefaultLogfileGroup("DEFAULT-LG");
+
+ int res;
+ res = pNdb->getDictionary()->createTablespace(lg);
+ if(res != 0){
+ g_err << "Failed to create tablespace:"
+ << endl << pNdb->getDictionary()->getNdbError() << endl;
+ return NDBT_FAILED;
+ }
+
+ NdbDictionary::Datafile uf;
+ uf.setPath("datafile01.dat");
+ uf.setSize(10*1024*1024);
+ uf.setTablespace("DEFAULT-TS");
+
+ res = pNdb->getDictionary()->createDatafile(uf);
+ if(res != 0){
+ g_err << "Failed to create datafile:"
+ << endl << pNdb->getDictionary()->getNdbError() << endl;
+ return NDBT_FAILED;
+ }
+
+ return NDBT_OK;
+}
+int
+runCreateDiskTable(NDBT_Context* ctx, NDBT_Step* step){
+ Ndb* pNdb = GETNDB(step);
+
+ NdbDictionary::Table tab = *ctx->getTab();
+ tab.setTablespace("DEFAULT-TS");
+
+ for(Uint32 i = 0; i<tab.getNoOfColumns(); i++)
+ if(!tab.getColumn(i)->getPrimaryKey())
+ tab.getColumn(i)->setStorageType(NdbDictionary::Column::StorageTypeDisk);
+
+ int res;
+ res = pNdb->getDictionary()->createTable(tab);
+ if(res != 0){
+ g_err << "Failed to create table:"
+ << endl << pNdb->getDictionary()->getNdbError() << endl;
+ return NDBT_FAILED;
+ }
+
+ return NDBT_OK;
+}
+
int runFailAddFragment(NDBT_Context* ctx, NDBT_Step* step){
static int acclst[] = { 3001 };
static int tuplst[] = { 4007, 4008, 4009, 4010, 4011, 4012 };
@@ -1854,7 +1947,9 @@
Ndb* pNdb = GETNDB(step);
NdbDictionary::Dictionary* pDic = pNdb->getDictionary();
const NdbDictionary::Table* pTab = ctx->getTab();
- const char* tabName = pTab->getName();
+ //const char* tabName = pTab->getName(); //XXX what goes on?
+ char tabName[40];
+ strcpy(tabName, pTab->getName());
const unsigned long maxsleep = 100; //ms
@@ -1890,7 +1985,7 @@
// replace by the Retrieved table
pTab = pTab2;
- int records = myRandom48(ctx->getNumRecords());
+ int records = ctx->getNumRecords();
g_info << "2: load " << records << " records" << endl;
HugoTransactions hugoTrans(*pTab);
if (hugoTrans.loadTable(pNdb, records) != 0) {
@@ -1927,7 +2022,8 @@
result = NDBT_FAILED;
break;
}
- if (pDic->getNdbError().code != 709) {
+ if (pDic->getNdbError().code != 709 &&
+ pDic->getNdbError().code != 723) {
const NdbError err = pDic->getNdbError();
g_err << "2: " << tabName << ": verify drop: " << err << endl;
result = NDBT_FAILED;
@@ -2044,6 +2140,15 @@
TESTCASE("DictionaryPerf",
""){
INITIALIZER(runTestDictionaryPerf);
+}
+TESTCASE("CreateLogfileGroup", ""){
+ INITIALIZER(runCreateLogfileGroup);
+}
+TESTCASE("CreateTablespace", ""){
+ INITIALIZER(runCreateTablespace);
+}
+TESTCASE("CreateDiskTable", ""){
+ INITIALIZER(runCreateDiskTable);
}
TESTCASE("FailAddFragment",
"Fail add fragment or attribute in ACC or TUP or TUX\n"){
--- 1.78/mysql-test/Makefile.am 2006-07-24 02:32:54 +10:00
+++ 1.79/mysql-test/Makefile.am 2006-07-24 02:32:54 +10:00
@@ -112,6 +112,7 @@
uninstall-local:
@RM@ -f -r $(DESTDIR)$(testdir)
+
SUFFIXES = .sh
.sh:
| Thread |
|---|
| • bk commit into 5.1 tree (stewart:1.2263) | Stewart Smith | 23 Jul |
