diff --git a/datatypes/mcs_datatype.h b/datatypes/mcs_datatype.h index 4bda25d0c..4202ddb8e 100644 --- a/datatypes/mcs_datatype.h +++ b/datatypes/mcs_datatype.h @@ -176,6 +176,11 @@ public: UNDEFINED, /*!< Undefined - used in UDAF API */ }; + // XXX: It is assumed here that ALL TYPES have width, scale and precision. + // XXX: And then some of them have the type tag itself. + // XXX: But, all types have type tag, some need explicit width (decimals, for example) + // XXX: and then some should have scale and precision (decimals, I guess). + // XXX: Current hierarchy is not all that straightforward to work with. class TypeAttributesStd { public: @@ -608,7 +613,59 @@ public: { int128Min = datatypes::minInt128; int128Max = datatypes::maxInt128; - }; + } + + /** @brief Returns ranges that is invalid for all signed values, both small and wide. */ + static MinMaxInfo invalidSignedRange() + { + MinMaxInfo tmp; + tmp.min = std::numeric_limits::max(); + tmp.max = std::numeric_limits::min(); + tmp.int128Max = datatypes::minInt128; + tmp.int128Min = datatypes::maxInt128; + return tmp; + } + /** @brief Returns ranges that is invalid for all unsigned values, both small and wide. */ + static MinMaxInfo invalidUnsignedRange() + { + MinMaxInfo tmp; + tmp.min = static_cast(std::numeric_limits::max()); + tmp.max = static_cast(std::numeric_limits::min()); + tmp.int128Max = datatypes::minInt128; // please bear in mind that DECIMAL(38) UNSIGNED + // has representable range 0..10^38-1 which is well + // inside int128 representable range. + tmp.int128Min = datatypes::maxInt128; + return tmp; + } + /** @brief convenience function for simpler access to invalid range. */ + static MinMaxInfo invalidRange(datatypes::SystemCatalog::ColDataType colType) + { + return isUnsigned(colType) ? invalidUnsignedRange() : invalidSignedRange(); + } + /** @brief Internal: type-casting comparison. */ + template + static bool greaterThan(ValueType a, ValueType b) + { + return static_cast(a) > static_cast(b); + } + /** @brief Check if range is valid + * + * A more general approach to check non-nullness of the range than + * explicit comparison with invalid bounds. + */ + static bool isRangeInvalid(const MinMaxInfo& mm, datatypes::SystemCatalog::ColDataType colType, int colWidth) + { + if (colWidth > 8) + { + return isUnsigned(colType) ? greaterThan(mm.int128Min, mm.int128Max) + : greaterThan(mm.int128Min, mm.int128Max); + } + else + { + return isUnsigned(colType) ? greaterThan(mm.min, mm.max) + : greaterThan(mm.min, mm.max); + } + } bool isEmptyOrNullSInt64() const { return min == std::numeric_limits::max() && diff --git a/dbcon/dmlpackageproc/commandpackageprocessor.cpp b/dbcon/dmlpackageproc/commandpackageprocessor.cpp index d18f7076c..994687724 100644 --- a/dbcon/dmlpackageproc/commandpackageprocessor.cpp +++ b/dbcon/dmlpackageproc/commandpackageprocessor.cpp @@ -430,7 +430,14 @@ CommandPackageProcessor::processPackage(dmlpackage::CalpontDMLPackage& cpackage) if (!cpInvalidated) { - fDbrm->invalidateUncommittedExtentLBIDs(0, &lbidList); + // The code below assumes that in case of COMMIT all ranges for all touched LBIDs + // are either correctly set or correctly reset. + // It is also assumes that ROLLBACK or other operations but COMMIT may not return ranges + // to state that is correct. This is why we invalidate extents when we are not committing. + if (stmt != "COMMIT") + { + fDbrm->invalidateUncommittedExtentLBIDs(0, &lbidList); + } } } } diff --git a/dbcon/dmlpackageproc/dmlpackageprocessor.cpp b/dbcon/dmlpackageproc/dmlpackageprocessor.cpp index c268f238a..1972fd838 100644 --- a/dbcon/dmlpackageproc/dmlpackageprocessor.cpp +++ b/dbcon/dmlpackageproc/dmlpackageprocessor.cpp @@ -485,37 +485,7 @@ int DMLPackageProcessor::commitBatchAutoOnTransaction(uint64_t uniqueId, BRM::Tx //set CP data before hwm. //cout << "setting hwm allHwm size " << allHwm.size() << endl; - vector lbidList; - - if (idbdatafile::IDBPolicy::useHdfs()) - { - BRM::LBID_t startLbid; - - for ( unsigned i = 0; i < allHwm.size(); i++) - { - rc = fDbrm->lookupLocalStartLbid(allHwm[i].oid, allHwm[i].partNum, allHwm[i].segNum, allHwm[i].hwm, startLbid); - lbidList.push_back(startLbid); - } - } - else - fDbrm->getUncommittedExtentLBIDs(static_cast(txnID.id), lbidList); - - vector::const_iterator iter = lbidList.begin(); - vector::const_iterator end = lbidList.end(); BRM::CPInfoList_t cpInfos; - BRM::CPInfo aInfo; - - while (iter != end) - { - aInfo.firstLbid = *iter; - aInfo.max = numeric_limits::min(); // Not used - aInfo.min = numeric_limits::max(); // Not used - utils::int128Min(aInfo.bigMax); // Not used - utils::int128Max(aInfo.bigMin); // Not used - aInfo.seqNum = -1; - cpInfos.push_back(aInfo); - ++iter; - } std::vector mergeCPDataArgs; rc = fDbrm->bulkSetHWMAndCP(allHwm, cpInfos, mergeCPDataArgs, txnID.id); diff --git a/mtr/basic/r/mcol2044_signed_bigint_delete-drop-max.result b/mtr/basic/r/mcol2044_signed_bigint_delete-drop-max.result new file mode 100644 index 000000000..320512500 --- /dev/null +++ b/mtr/basic/r/mcol2044_signed_bigint_delete-drop-max.result @@ -0,0 +1,13 @@ +create database if not exists test_ranges; +use test_ranges; +drop table if exists t; +create table t(x bigint) engine=columnstore; +insert into t(x) values (44),(55),(66); +select max_value, min_value from information_schema.columnstore_extents; +max_value min_value +66 44 +delete from t where x=44; +select max_value, min_value from information_schema.columnstore_extents; +max_value min_value +NULL NULL +drop database test_ranges; diff --git a/mtr/basic/r/mcol2044_signed_bigint_delete-drop-min.result b/mtr/basic/r/mcol2044_signed_bigint_delete-drop-min.result new file mode 100644 index 000000000..2561d5f4b --- /dev/null +++ b/mtr/basic/r/mcol2044_signed_bigint_delete-drop-min.result @@ -0,0 +1,13 @@ +create database if not exists test_ranges; +use test_ranges; +drop table if exists t; +create table t(x bigint) engine=columnstore; +insert into t(x) values (44),(55),(66); +select max_value, min_value from information_schema.columnstore_extents; +max_value min_value +66 44 +delete from t where x=66; +select max_value, min_value from information_schema.columnstore_extents; +max_value min_value +NULL NULL +drop database test_ranges; diff --git a/mtr/basic/r/mcol2044_signed_bigint_delete-within-range.result b/mtr/basic/r/mcol2044_signed_bigint_delete-within-range.result new file mode 100644 index 000000000..d0bd516dc --- /dev/null +++ b/mtr/basic/r/mcol2044_signed_bigint_delete-within-range.result @@ -0,0 +1,10 @@ +create database if not exists test_ranges; +use test_ranges; +drop table if exists t; +create table t(x bigint) engine=columnstore; +insert into t(x) values (44),(55),(66); +delete from t where x=55; +select max_value, min_value from information_schema.columnstore_extents; +max_value min_value +66 44 +drop database test_ranges; diff --git a/mtr/basic/r/mcol2044_signed_bigint_insert-keeps-invalid-range.result b/mtr/basic/r/mcol2044_signed_bigint_insert-keeps-invalid-range.result new file mode 100644 index 000000000..d7d315cf9 --- /dev/null +++ b/mtr/basic/r/mcol2044_signed_bigint_insert-keeps-invalid-range.result @@ -0,0 +1,11 @@ +create database if not exists test_ranges; +use test_ranges; +drop table if exists t; +create table t(x bigint) engine=columnstore; +insert into t(x) values (44),(55),(66); +update t set x=65 where x=66; +insert into t(x) values (77), (22); +select max_value, min_value from information_schema.columnstore_extents; +max_value min_value +NULL NULL +drop database test_ranges; diff --git a/mtr/basic/r/mcol2044_signed_bigint_update-drop-max.result b/mtr/basic/r/mcol2044_signed_bigint_update-drop-max.result new file mode 100644 index 000000000..74bf01152 --- /dev/null +++ b/mtr/basic/r/mcol2044_signed_bigint_update-drop-max.result @@ -0,0 +1,10 @@ +create database if not exists test_ranges; +use test_ranges; +drop table if exists t; +create table t(x bigint) engine=columnstore; +insert into t(x) values (44),(55),(66); +update t set x=65 where x=44; +select max_value, min_value from information_schema.columnstore_extents; +max_value min_value +NULL NULL +drop database test_ranges; diff --git a/mtr/basic/r/mcol2044_signed_bigint_update-drop-min.result b/mtr/basic/r/mcol2044_signed_bigint_update-drop-min.result new file mode 100644 index 000000000..74bf01152 --- /dev/null +++ b/mtr/basic/r/mcol2044_signed_bigint_update-drop-min.result @@ -0,0 +1,10 @@ +create database if not exists test_ranges; +use test_ranges; +drop table if exists t; +create table t(x bigint) engine=columnstore; +insert into t(x) values (44),(55),(66); +update t set x=65 where x=44; +select max_value, min_value from information_schema.columnstore_extents; +max_value min_value +NULL NULL +drop database test_ranges; diff --git a/mtr/basic/r/mcol2044_signed_bigint_update-extends-max.result b/mtr/basic/r/mcol2044_signed_bigint_update-extends-max.result new file mode 100644 index 000000000..d44e1c967 --- /dev/null +++ b/mtr/basic/r/mcol2044_signed_bigint_update-extends-max.result @@ -0,0 +1,10 @@ +create database if not exists test_ranges; +use test_ranges; +drop table if exists t; +create table t(x bigint) engine=columnstore; +insert into t(x) values (44),(55),(66); +update t set x=77 where x=66; +select max_value, min_value from information_schema.columnstore_extents; +max_value min_value +77 44 +drop database test_ranges; diff --git a/mtr/basic/r/mcol2044_signed_bigint_update-extends-min.result b/mtr/basic/r/mcol2044_signed_bigint_update-extends-min.result new file mode 100644 index 000000000..d0d5e2e87 --- /dev/null +++ b/mtr/basic/r/mcol2044_signed_bigint_update-extends-min.result @@ -0,0 +1,10 @@ +create database if not exists test_ranges; +use test_ranges; +drop table if exists t; +create table t(x bigint) engine=columnstore; +insert into t(x) values (44),(55),(66); +update t set x=33 where x=44; +select max_value, min_value from information_schema.columnstore_extents; +max_value min_value +66 33 +drop database test_ranges; diff --git a/mtr/basic/r/mcol2044_signed_bigint_update-within-range.result b/mtr/basic/r/mcol2044_signed_bigint_update-within-range.result new file mode 100644 index 000000000..d2065758f --- /dev/null +++ b/mtr/basic/r/mcol2044_signed_bigint_update-within-range.result @@ -0,0 +1,10 @@ +create database if not exists test_ranges; +use test_ranges; +drop table if exists t; +create table t(x bigint) engine=columnstore; +insert into t(x) values (44),(55),(66); +update t set x=65 where x=55; +select max_value, min_value from information_schema.columnstore_extents; +max_value min_value +66 44 +drop database test_ranges; diff --git a/mtr/basic/r/mcol2044_signed_dec38_delete-drop-max.result b/mtr/basic/r/mcol2044_signed_dec38_delete-drop-max.result new file mode 100644 index 000000000..a7dcf4589 --- /dev/null +++ b/mtr/basic/r/mcol2044_signed_dec38_delete-drop-max.result @@ -0,0 +1,13 @@ +create database if not exists test_ranges; +use test_ranges; +drop table if exists t; +create table t(x decimal(38)) engine=columnstore; +insert into t(x) values (44),(55),(66); +select max_value, min_value from information_schema.columnstore_extents; +max_value min_value +66 44 +delete from t where x=44; +select max_value, min_value from information_schema.columnstore_extents; +max_value min_value +NULL NULL +drop database test_ranges; diff --git a/mtr/basic/r/mcol2044_signed_dec38_delete-drop-min.result b/mtr/basic/r/mcol2044_signed_dec38_delete-drop-min.result new file mode 100644 index 000000000..6b7ce8ffb --- /dev/null +++ b/mtr/basic/r/mcol2044_signed_dec38_delete-drop-min.result @@ -0,0 +1,13 @@ +create database if not exists test_ranges; +use test_ranges; +drop table if exists t; +create table t(x decimal(38)) engine=columnstore; +insert into t(x) values (44),(55),(66); +select max_value, min_value from information_schema.columnstore_extents; +max_value min_value +66 44 +delete from t where x=66; +select max_value, min_value from information_schema.columnstore_extents; +max_value min_value +NULL NULL +drop database test_ranges; diff --git a/mtr/basic/r/mcol2044_signed_dec38_delete-within-range.result b/mtr/basic/r/mcol2044_signed_dec38_delete-within-range.result new file mode 100644 index 000000000..b15da18b3 --- /dev/null +++ b/mtr/basic/r/mcol2044_signed_dec38_delete-within-range.result @@ -0,0 +1,10 @@ +create database if not exists test_ranges; +use test_ranges; +drop table if exists t; +create table t(x decimal(38)) engine=columnstore; +insert into t(x) values (44),(55),(66); +delete from t where x=55; +select max_value, min_value from information_schema.columnstore_extents; +max_value min_value +66 44 +drop database test_ranges; diff --git a/mtr/basic/r/mcol2044_signed_dec38_insert-keeps-invalid-range.result b/mtr/basic/r/mcol2044_signed_dec38_insert-keeps-invalid-range.result new file mode 100644 index 000000000..ec3ae3815 --- /dev/null +++ b/mtr/basic/r/mcol2044_signed_dec38_insert-keeps-invalid-range.result @@ -0,0 +1,11 @@ +create database if not exists test_ranges; +use test_ranges; +drop table if exists t; +create table t(x decimal(38)) engine=columnstore; +insert into t(x) values (44),(55),(66); +update t set x=65 where x=66; +insert into t(x) values (77), (22); +select max_value, min_value from information_schema.columnstore_extents; +max_value min_value +NULL NULL +drop database test_ranges; diff --git a/mtr/basic/r/mcol2044_signed_dec38_update-drop-max.result b/mtr/basic/r/mcol2044_signed_dec38_update-drop-max.result new file mode 100644 index 000000000..8b6344568 --- /dev/null +++ b/mtr/basic/r/mcol2044_signed_dec38_update-drop-max.result @@ -0,0 +1,10 @@ +create database if not exists test_ranges; +use test_ranges; +drop table if exists t; +create table t(x decimal(38)) engine=columnstore; +insert into t(x) values (44),(55),(66); +update t set x=65 where x=44; +select max_value, min_value from information_schema.columnstore_extents; +max_value min_value +NULL NULL +drop database test_ranges; diff --git a/mtr/basic/r/mcol2044_signed_dec38_update-drop-min.result b/mtr/basic/r/mcol2044_signed_dec38_update-drop-min.result new file mode 100644 index 000000000..8b6344568 --- /dev/null +++ b/mtr/basic/r/mcol2044_signed_dec38_update-drop-min.result @@ -0,0 +1,10 @@ +create database if not exists test_ranges; +use test_ranges; +drop table if exists t; +create table t(x decimal(38)) engine=columnstore; +insert into t(x) values (44),(55),(66); +update t set x=65 where x=44; +select max_value, min_value from information_schema.columnstore_extents; +max_value min_value +NULL NULL +drop database test_ranges; diff --git a/mtr/basic/r/mcol2044_signed_dec38_update-extends-max.result b/mtr/basic/r/mcol2044_signed_dec38_update-extends-max.result new file mode 100644 index 000000000..949df940f --- /dev/null +++ b/mtr/basic/r/mcol2044_signed_dec38_update-extends-max.result @@ -0,0 +1,10 @@ +create database if not exists test_ranges; +use test_ranges; +drop table if exists t; +create table t(x decimal(38)) engine=columnstore; +insert into t(x) values (44),(55),(66); +update t set x=77 where x=66; +select max_value, min_value from information_schema.columnstore_extents; +max_value min_value +77 44 +drop database test_ranges; diff --git a/mtr/basic/r/mcol2044_signed_dec38_update-extends-min.result b/mtr/basic/r/mcol2044_signed_dec38_update-extends-min.result new file mode 100644 index 000000000..407ee58dc --- /dev/null +++ b/mtr/basic/r/mcol2044_signed_dec38_update-extends-min.result @@ -0,0 +1,10 @@ +create database if not exists test_ranges; +use test_ranges; +drop table if exists t; +create table t(x decimal(38)) engine=columnstore; +insert into t(x) values (44),(55),(66); +update t set x=33 where x=44; +select max_value, min_value from information_schema.columnstore_extents; +max_value min_value +66 33 +drop database test_ranges; diff --git a/mtr/basic/r/mcol2044_signed_dec38_update-within-range.result b/mtr/basic/r/mcol2044_signed_dec38_update-within-range.result new file mode 100644 index 000000000..cd2245a25 --- /dev/null +++ b/mtr/basic/r/mcol2044_signed_dec38_update-within-range.result @@ -0,0 +1,10 @@ +create database if not exists test_ranges; +use test_ranges; +drop table if exists t; +create table t(x decimal(38)) engine=columnstore; +insert into t(x) values (44),(55),(66); +update t set x=65 where x=55; +select max_value, min_value from information_schema.columnstore_extents; +max_value min_value +66 44 +drop database test_ranges; diff --git a/mtr/basic/r/mcol2044_signed_integer_delete-drop-max.result b/mtr/basic/r/mcol2044_signed_integer_delete-drop-max.result new file mode 100644 index 000000000..851bd67ce --- /dev/null +++ b/mtr/basic/r/mcol2044_signed_integer_delete-drop-max.result @@ -0,0 +1,13 @@ +create database if not exists test_ranges; +use test_ranges; +drop table if exists t; +create table t(x integer) engine=columnstore; +insert into t(x) values (44),(55),(66); +select max_value, min_value from information_schema.columnstore_extents; +max_value min_value +66 44 +delete from t where x=44; +select max_value, min_value from information_schema.columnstore_extents; +max_value min_value +NULL NULL +drop database test_ranges; diff --git a/mtr/basic/r/mcol2044_signed_integer_delete-drop-min.result b/mtr/basic/r/mcol2044_signed_integer_delete-drop-min.result new file mode 100644 index 000000000..08dd70546 --- /dev/null +++ b/mtr/basic/r/mcol2044_signed_integer_delete-drop-min.result @@ -0,0 +1,13 @@ +create database if not exists test_ranges; +use test_ranges; +drop table if exists t; +create table t(x integer) engine=columnstore; +insert into t(x) values (44),(55),(66); +select max_value, min_value from information_schema.columnstore_extents; +max_value min_value +66 44 +delete from t where x=66; +select max_value, min_value from information_schema.columnstore_extents; +max_value min_value +NULL NULL +drop database test_ranges; diff --git a/mtr/basic/r/mcol2044_signed_integer_delete-within-range.result b/mtr/basic/r/mcol2044_signed_integer_delete-within-range.result new file mode 100644 index 000000000..481b800a0 --- /dev/null +++ b/mtr/basic/r/mcol2044_signed_integer_delete-within-range.result @@ -0,0 +1,10 @@ +create database if not exists test_ranges; +use test_ranges; +drop table if exists t; +create table t(x integer) engine=columnstore; +insert into t(x) values (44),(55),(66); +delete from t where x=55; +select max_value, min_value from information_schema.columnstore_extents; +max_value min_value +66 44 +drop database test_ranges; diff --git a/mtr/basic/r/mcol2044_signed_integer_insert-keeps-invalid-range.result b/mtr/basic/r/mcol2044_signed_integer_insert-keeps-invalid-range.result new file mode 100644 index 000000000..105bbbfbf --- /dev/null +++ b/mtr/basic/r/mcol2044_signed_integer_insert-keeps-invalid-range.result @@ -0,0 +1,11 @@ +create database if not exists test_ranges; +use test_ranges; +drop table if exists t; +create table t(x integer) engine=columnstore; +insert into t(x) values (44),(55),(66); +update t set x=65 where x=66; +insert into t(x) values (77), (22); +select max_value, min_value from information_schema.columnstore_extents; +max_value min_value +NULL NULL +drop database test_ranges; diff --git a/mtr/basic/r/mcol2044_signed_integer_update-drop-max.result b/mtr/basic/r/mcol2044_signed_integer_update-drop-max.result new file mode 100644 index 000000000..2b4f90222 --- /dev/null +++ b/mtr/basic/r/mcol2044_signed_integer_update-drop-max.result @@ -0,0 +1,10 @@ +create database if not exists test_ranges; +use test_ranges; +drop table if exists t; +create table t(x integer) engine=columnstore; +insert into t(x) values (44),(55),(66); +update t set x=65 where x=44; +select max_value, min_value from information_schema.columnstore_extents; +max_value min_value +NULL NULL +drop database test_ranges; diff --git a/mtr/basic/r/mcol2044_signed_integer_update-drop-min.result b/mtr/basic/r/mcol2044_signed_integer_update-drop-min.result new file mode 100644 index 000000000..2b4f90222 --- /dev/null +++ b/mtr/basic/r/mcol2044_signed_integer_update-drop-min.result @@ -0,0 +1,10 @@ +create database if not exists test_ranges; +use test_ranges; +drop table if exists t; +create table t(x integer) engine=columnstore; +insert into t(x) values (44),(55),(66); +update t set x=65 where x=44; +select max_value, min_value from information_schema.columnstore_extents; +max_value min_value +NULL NULL +drop database test_ranges; diff --git a/mtr/basic/r/mcol2044_signed_integer_update-extends-max.result b/mtr/basic/r/mcol2044_signed_integer_update-extends-max.result new file mode 100644 index 000000000..10741f45c --- /dev/null +++ b/mtr/basic/r/mcol2044_signed_integer_update-extends-max.result @@ -0,0 +1,10 @@ +create database if not exists test_ranges; +use test_ranges; +drop table if exists t; +create table t(x integer) engine=columnstore; +insert into t(x) values (44),(55),(66); +update t set x=77 where x=66; +select max_value, min_value from information_schema.columnstore_extents; +max_value min_value +77 44 +drop database test_ranges; diff --git a/mtr/basic/r/mcol2044_signed_integer_update-extends-min.result b/mtr/basic/r/mcol2044_signed_integer_update-extends-min.result new file mode 100644 index 000000000..3d4825f40 --- /dev/null +++ b/mtr/basic/r/mcol2044_signed_integer_update-extends-min.result @@ -0,0 +1,10 @@ +create database if not exists test_ranges; +use test_ranges; +drop table if exists t; +create table t(x integer) engine=columnstore; +insert into t(x) values (44),(55),(66); +update t set x=33 where x=44; +select max_value, min_value from information_schema.columnstore_extents; +max_value min_value +66 33 +drop database test_ranges; diff --git a/mtr/basic/r/mcol2044_signed_integer_update-within-range.result b/mtr/basic/r/mcol2044_signed_integer_update-within-range.result new file mode 100644 index 000000000..a7442b727 --- /dev/null +++ b/mtr/basic/r/mcol2044_signed_integer_update-within-range.result @@ -0,0 +1,10 @@ +create database if not exists test_ranges; +use test_ranges; +drop table if exists t; +create table t(x integer) engine=columnstore; +insert into t(x) values (44),(55),(66); +update t set x=65 where x=55; +select max_value, min_value from information_schema.columnstore_extents; +max_value min_value +66 44 +drop database test_ranges; diff --git a/mtr/basic/r/mcol2044_signed_smallint_delete-drop-max.result b/mtr/basic/r/mcol2044_signed_smallint_delete-drop-max.result new file mode 100644 index 000000000..818b76388 --- /dev/null +++ b/mtr/basic/r/mcol2044_signed_smallint_delete-drop-max.result @@ -0,0 +1,13 @@ +create database if not exists test_ranges; +use test_ranges; +drop table if exists t; +create table t(x smallint) engine=columnstore; +insert into t(x) values (44),(55),(66); +select max_value, min_value from information_schema.columnstore_extents; +max_value min_value +66 44 +delete from t where x=44; +select max_value, min_value from information_schema.columnstore_extents; +max_value min_value +NULL NULL +drop database test_ranges; diff --git a/mtr/basic/r/mcol2044_signed_smallint_delete-drop-min.result b/mtr/basic/r/mcol2044_signed_smallint_delete-drop-min.result new file mode 100644 index 000000000..ceb9393b8 --- /dev/null +++ b/mtr/basic/r/mcol2044_signed_smallint_delete-drop-min.result @@ -0,0 +1,13 @@ +create database if not exists test_ranges; +use test_ranges; +drop table if exists t; +create table t(x smallint) engine=columnstore; +insert into t(x) values (44),(55),(66); +select max_value, min_value from information_schema.columnstore_extents; +max_value min_value +66 44 +delete from t where x=66; +select max_value, min_value from information_schema.columnstore_extents; +max_value min_value +NULL NULL +drop database test_ranges; diff --git a/mtr/basic/r/mcol2044_signed_smallint_delete-within-range.result b/mtr/basic/r/mcol2044_signed_smallint_delete-within-range.result new file mode 100644 index 000000000..b50c08bbb --- /dev/null +++ b/mtr/basic/r/mcol2044_signed_smallint_delete-within-range.result @@ -0,0 +1,10 @@ +create database if not exists test_ranges; +use test_ranges; +drop table if exists t; +create table t(x smallint) engine=columnstore; +insert into t(x) values (44),(55),(66); +delete from t where x=55; +select max_value, min_value from information_schema.columnstore_extents; +max_value min_value +66 44 +drop database test_ranges; diff --git a/mtr/basic/r/mcol2044_signed_smallint_insert-keeps-invalid-range.result b/mtr/basic/r/mcol2044_signed_smallint_insert-keeps-invalid-range.result new file mode 100644 index 000000000..645c3d4e8 --- /dev/null +++ b/mtr/basic/r/mcol2044_signed_smallint_insert-keeps-invalid-range.result @@ -0,0 +1,11 @@ +create database if not exists test_ranges; +use test_ranges; +drop table if exists t; +create table t(x smallint) engine=columnstore; +insert into t(x) values (44),(55),(66); +update t set x=65 where x=66; +insert into t(x) values (77), (22); +select max_value, min_value from information_schema.columnstore_extents; +max_value min_value +NULL NULL +drop database test_ranges; diff --git a/mtr/basic/r/mcol2044_signed_smallint_update-drop-max.result b/mtr/basic/r/mcol2044_signed_smallint_update-drop-max.result new file mode 100644 index 000000000..fdf6aff43 --- /dev/null +++ b/mtr/basic/r/mcol2044_signed_smallint_update-drop-max.result @@ -0,0 +1,10 @@ +create database if not exists test_ranges; +use test_ranges; +drop table if exists t; +create table t(x smallint) engine=columnstore; +insert into t(x) values (44),(55),(66); +update t set x=65 where x=44; +select max_value, min_value from information_schema.columnstore_extents; +max_value min_value +NULL NULL +drop database test_ranges; diff --git a/mtr/basic/r/mcol2044_signed_smallint_update-drop-min.result b/mtr/basic/r/mcol2044_signed_smallint_update-drop-min.result new file mode 100644 index 000000000..fdf6aff43 --- /dev/null +++ b/mtr/basic/r/mcol2044_signed_smallint_update-drop-min.result @@ -0,0 +1,10 @@ +create database if not exists test_ranges; +use test_ranges; +drop table if exists t; +create table t(x smallint) engine=columnstore; +insert into t(x) values (44),(55),(66); +update t set x=65 where x=44; +select max_value, min_value from information_schema.columnstore_extents; +max_value min_value +NULL NULL +drop database test_ranges; diff --git a/mtr/basic/r/mcol2044_signed_smallint_update-extends-max.result b/mtr/basic/r/mcol2044_signed_smallint_update-extends-max.result new file mode 100644 index 000000000..45d41f443 --- /dev/null +++ b/mtr/basic/r/mcol2044_signed_smallint_update-extends-max.result @@ -0,0 +1,10 @@ +create database if not exists test_ranges; +use test_ranges; +drop table if exists t; +create table t(x smallint) engine=columnstore; +insert into t(x) values (44),(55),(66); +update t set x=77 where x=66; +select max_value, min_value from information_schema.columnstore_extents; +max_value min_value +77 44 +drop database test_ranges; diff --git a/mtr/basic/r/mcol2044_signed_smallint_update-extends-min.result b/mtr/basic/r/mcol2044_signed_smallint_update-extends-min.result new file mode 100644 index 000000000..3948037aa --- /dev/null +++ b/mtr/basic/r/mcol2044_signed_smallint_update-extends-min.result @@ -0,0 +1,10 @@ +create database if not exists test_ranges; +use test_ranges; +drop table if exists t; +create table t(x smallint) engine=columnstore; +insert into t(x) values (44),(55),(66); +update t set x=33 where x=44; +select max_value, min_value from information_schema.columnstore_extents; +max_value min_value +66 33 +drop database test_ranges; diff --git a/mtr/basic/r/mcol2044_signed_smallint_update-within-range.result b/mtr/basic/r/mcol2044_signed_smallint_update-within-range.result new file mode 100644 index 000000000..96b15f1d6 --- /dev/null +++ b/mtr/basic/r/mcol2044_signed_smallint_update-within-range.result @@ -0,0 +1,10 @@ +create database if not exists test_ranges; +use test_ranges; +drop table if exists t; +create table t(x smallint) engine=columnstore; +insert into t(x) values (44),(55),(66); +update t set x=65 where x=55; +select max_value, min_value from information_schema.columnstore_extents; +max_value min_value +66 44 +drop database test_ranges; diff --git a/mtr/basic/r/mcol2044_signed_tinyint_delete-drop-max.result b/mtr/basic/r/mcol2044_signed_tinyint_delete-drop-max.result new file mode 100644 index 000000000..d85d16b39 --- /dev/null +++ b/mtr/basic/r/mcol2044_signed_tinyint_delete-drop-max.result @@ -0,0 +1,13 @@ +create database if not exists test_ranges; +use test_ranges; +drop table if exists t; +create table t(x tinyint) engine=columnstore; +insert into t(x) values (44),(55),(66); +select max_value, min_value from information_schema.columnstore_extents; +max_value min_value +66 44 +delete from t where x=44; +select max_value, min_value from information_schema.columnstore_extents; +max_value min_value +NULL NULL +drop database test_ranges; diff --git a/mtr/basic/r/mcol2044_signed_tinyint_delete-drop-min.result b/mtr/basic/r/mcol2044_signed_tinyint_delete-drop-min.result new file mode 100644 index 000000000..c32737cb4 --- /dev/null +++ b/mtr/basic/r/mcol2044_signed_tinyint_delete-drop-min.result @@ -0,0 +1,13 @@ +create database if not exists test_ranges; +use test_ranges; +drop table if exists t; +create table t(x tinyint) engine=columnstore; +insert into t(x) values (44),(55),(66); +select max_value, min_value from information_schema.columnstore_extents; +max_value min_value +66 44 +delete from t where x=66; +select max_value, min_value from information_schema.columnstore_extents; +max_value min_value +NULL NULL +drop database test_ranges; diff --git a/mtr/basic/r/mcol2044_signed_tinyint_delete-within-range.result b/mtr/basic/r/mcol2044_signed_tinyint_delete-within-range.result new file mode 100644 index 000000000..aec50e20a --- /dev/null +++ b/mtr/basic/r/mcol2044_signed_tinyint_delete-within-range.result @@ -0,0 +1,10 @@ +create database if not exists test_ranges; +use test_ranges; +drop table if exists t; +create table t(x tinyint) engine=columnstore; +insert into t(x) values (44),(55),(66); +delete from t where x=55; +select max_value, min_value from information_schema.columnstore_extents; +max_value min_value +66 44 +drop database test_ranges; diff --git a/mtr/basic/r/mcol2044_signed_tinyint_insert-keeps-invalid-range.result b/mtr/basic/r/mcol2044_signed_tinyint_insert-keeps-invalid-range.result new file mode 100644 index 000000000..56d2b2f09 --- /dev/null +++ b/mtr/basic/r/mcol2044_signed_tinyint_insert-keeps-invalid-range.result @@ -0,0 +1,11 @@ +create database if not exists test_ranges; +use test_ranges; +drop table if exists t; +create table t(x tinyint) engine=columnstore; +insert into t(x) values (44),(55),(66); +update t set x=65 where x=66; +insert into t(x) values (77), (22); +select max_value, min_value from information_schema.columnstore_extents; +max_value min_value +NULL NULL +drop database test_ranges; diff --git a/mtr/basic/r/mcol2044_signed_tinyint_update-drop-max.result b/mtr/basic/r/mcol2044_signed_tinyint_update-drop-max.result new file mode 100644 index 000000000..a7a1ecea8 --- /dev/null +++ b/mtr/basic/r/mcol2044_signed_tinyint_update-drop-max.result @@ -0,0 +1,10 @@ +create database if not exists test_ranges; +use test_ranges; +drop table if exists t; +create table t(x tinyint) engine=columnstore; +insert into t(x) values (44),(55),(66); +update t set x=65 where x=44; +select max_value, min_value from information_schema.columnstore_extents; +max_value min_value +NULL NULL +drop database test_ranges; diff --git a/mtr/basic/r/mcol2044_signed_tinyint_update-drop-min.result b/mtr/basic/r/mcol2044_signed_tinyint_update-drop-min.result new file mode 100644 index 000000000..a7a1ecea8 --- /dev/null +++ b/mtr/basic/r/mcol2044_signed_tinyint_update-drop-min.result @@ -0,0 +1,10 @@ +create database if not exists test_ranges; +use test_ranges; +drop table if exists t; +create table t(x tinyint) engine=columnstore; +insert into t(x) values (44),(55),(66); +update t set x=65 where x=44; +select max_value, min_value from information_schema.columnstore_extents; +max_value min_value +NULL NULL +drop database test_ranges; diff --git a/mtr/basic/r/mcol2044_signed_tinyint_update-extends-max.result b/mtr/basic/r/mcol2044_signed_tinyint_update-extends-max.result new file mode 100644 index 000000000..32a421b74 --- /dev/null +++ b/mtr/basic/r/mcol2044_signed_tinyint_update-extends-max.result @@ -0,0 +1,10 @@ +create database if not exists test_ranges; +use test_ranges; +drop table if exists t; +create table t(x tinyint) engine=columnstore; +insert into t(x) values (44),(55),(66); +update t set x=77 where x=66; +select max_value, min_value from information_schema.columnstore_extents; +max_value min_value +77 44 +drop database test_ranges; diff --git a/mtr/basic/r/mcol2044_signed_tinyint_update-extends-min.result b/mtr/basic/r/mcol2044_signed_tinyint_update-extends-min.result new file mode 100644 index 000000000..fe05bdf84 --- /dev/null +++ b/mtr/basic/r/mcol2044_signed_tinyint_update-extends-min.result @@ -0,0 +1,10 @@ +create database if not exists test_ranges; +use test_ranges; +drop table if exists t; +create table t(x tinyint) engine=columnstore; +insert into t(x) values (44),(55),(66); +update t set x=33 where x=44; +select max_value, min_value from information_schema.columnstore_extents; +max_value min_value +66 33 +drop database test_ranges; diff --git a/mtr/basic/r/mcol2044_signed_tinyint_update-within-range.result b/mtr/basic/r/mcol2044_signed_tinyint_update-within-range.result new file mode 100644 index 000000000..61906f967 --- /dev/null +++ b/mtr/basic/r/mcol2044_signed_tinyint_update-within-range.result @@ -0,0 +1,10 @@ +create database if not exists test_ranges; +use test_ranges; +drop table if exists t; +create table t(x tinyint) engine=columnstore; +insert into t(x) values (44),(55),(66); +update t set x=65 where x=55; +select max_value, min_value from information_schema.columnstore_extents; +max_value min_value +66 44 +drop database test_ranges; diff --git a/mtr/basic/r/mcol2044_unsigned_bigint_delete-drop-max.result b/mtr/basic/r/mcol2044_unsigned_bigint_delete-drop-max.result new file mode 100644 index 000000000..aec7a1544 --- /dev/null +++ b/mtr/basic/r/mcol2044_unsigned_bigint_delete-drop-max.result @@ -0,0 +1,13 @@ +create database if not exists test_ranges; +use test_ranges; +drop table if exists t; +create table t(x bigint unsigned) engine=columnstore; +insert into t(x) values (44),(55),(66); +select max_value, min_value from information_schema.columnstore_extents; +max_value min_value +66 44 +delete from t where x=44; +select max_value, min_value from information_schema.columnstore_extents; +max_value min_value +0 -1 +drop database test_ranges; diff --git a/mtr/basic/r/mcol2044_unsigned_bigint_delete-drop-min.result b/mtr/basic/r/mcol2044_unsigned_bigint_delete-drop-min.result new file mode 100644 index 000000000..2d1b3b253 --- /dev/null +++ b/mtr/basic/r/mcol2044_unsigned_bigint_delete-drop-min.result @@ -0,0 +1,13 @@ +create database if not exists test_ranges; +use test_ranges; +drop table if exists t; +create table t(x bigint unsigned) engine=columnstore; +insert into t(x) values (44),(55),(66); +select max_value, min_value from information_schema.columnstore_extents; +max_value min_value +66 44 +delete from t where x=66; +select max_value, min_value from information_schema.columnstore_extents; +max_value min_value +0 -1 +drop database test_ranges; diff --git a/mtr/basic/r/mcol2044_unsigned_bigint_delete-within-range.result b/mtr/basic/r/mcol2044_unsigned_bigint_delete-within-range.result new file mode 100644 index 000000000..8511fc74f --- /dev/null +++ b/mtr/basic/r/mcol2044_unsigned_bigint_delete-within-range.result @@ -0,0 +1,10 @@ +create database if not exists test_ranges; +use test_ranges; +drop table if exists t; +create table t(x bigint unsigned) engine=columnstore; +insert into t(x) values (44),(55),(66); +delete from t where x=55; +select max_value, min_value from information_schema.columnstore_extents; +max_value min_value +66 44 +drop database test_ranges; diff --git a/mtr/basic/r/mcol2044_unsigned_bigint_insert-keeps-invalid-range.result b/mtr/basic/r/mcol2044_unsigned_bigint_insert-keeps-invalid-range.result new file mode 100644 index 000000000..d0cd14269 --- /dev/null +++ b/mtr/basic/r/mcol2044_unsigned_bigint_insert-keeps-invalid-range.result @@ -0,0 +1,11 @@ +create database if not exists test_ranges; +use test_ranges; +drop table if exists t; +create table t(x bigint unsigned) engine=columnstore; +insert into t(x) values (44),(55),(66); +update t set x=65 where x=66; +insert into t(x) values (77), (22); +select max_value, min_value from information_schema.columnstore_extents; +max_value min_value +0 -1 +drop database test_ranges; diff --git a/mtr/basic/r/mcol2044_unsigned_bigint_update-drop-max.result b/mtr/basic/r/mcol2044_unsigned_bigint_update-drop-max.result new file mode 100644 index 000000000..7843ca2ab --- /dev/null +++ b/mtr/basic/r/mcol2044_unsigned_bigint_update-drop-max.result @@ -0,0 +1,10 @@ +create database if not exists test_ranges; +use test_ranges; +drop table if exists t; +create table t(x bigint unsigned) engine=columnstore; +insert into t(x) values (44),(55),(66); +update t set x=65 where x=44; +select max_value, min_value from information_schema.columnstore_extents; +max_value min_value +0 -1 +drop database test_ranges; diff --git a/mtr/basic/r/mcol2044_unsigned_bigint_update-drop-min.result b/mtr/basic/r/mcol2044_unsigned_bigint_update-drop-min.result new file mode 100644 index 000000000..7843ca2ab --- /dev/null +++ b/mtr/basic/r/mcol2044_unsigned_bigint_update-drop-min.result @@ -0,0 +1,10 @@ +create database if not exists test_ranges; +use test_ranges; +drop table if exists t; +create table t(x bigint unsigned) engine=columnstore; +insert into t(x) values (44),(55),(66); +update t set x=65 where x=44; +select max_value, min_value from information_schema.columnstore_extents; +max_value min_value +0 -1 +drop database test_ranges; diff --git a/mtr/basic/r/mcol2044_unsigned_bigint_update-extends-max.result b/mtr/basic/r/mcol2044_unsigned_bigint_update-extends-max.result new file mode 100644 index 000000000..d47d09b8e --- /dev/null +++ b/mtr/basic/r/mcol2044_unsigned_bigint_update-extends-max.result @@ -0,0 +1,10 @@ +create database if not exists test_ranges; +use test_ranges; +drop table if exists t; +create table t(x bigint unsigned) engine=columnstore; +insert into t(x) values (44),(55),(66); +update t set x=77 where x=66; +select max_value, min_value from information_schema.columnstore_extents; +max_value min_value +77 44 +drop database test_ranges; diff --git a/mtr/basic/r/mcol2044_unsigned_bigint_update-extends-min.result b/mtr/basic/r/mcol2044_unsigned_bigint_update-extends-min.result new file mode 100644 index 000000000..8ebafe1e9 --- /dev/null +++ b/mtr/basic/r/mcol2044_unsigned_bigint_update-extends-min.result @@ -0,0 +1,10 @@ +create database if not exists test_ranges; +use test_ranges; +drop table if exists t; +create table t(x bigint unsigned) engine=columnstore; +insert into t(x) values (44),(55),(66); +update t set x=33 where x=44; +select max_value, min_value from information_schema.columnstore_extents; +max_value min_value +66 33 +drop database test_ranges; diff --git a/mtr/basic/r/mcol2044_unsigned_bigint_update-within-range.result b/mtr/basic/r/mcol2044_unsigned_bigint_update-within-range.result new file mode 100644 index 000000000..8a543761d --- /dev/null +++ b/mtr/basic/r/mcol2044_unsigned_bigint_update-within-range.result @@ -0,0 +1,10 @@ +create database if not exists test_ranges; +use test_ranges; +drop table if exists t; +create table t(x bigint unsigned) engine=columnstore; +insert into t(x) values (44),(55),(66); +update t set x=65 where x=55; +select max_value, min_value from information_schema.columnstore_extents; +max_value min_value +66 44 +drop database test_ranges; diff --git a/mtr/basic/r/mcol2044_unsigned_dec38_delete-drop-max.result b/mtr/basic/r/mcol2044_unsigned_dec38_delete-drop-max.result new file mode 100644 index 000000000..aec7a1544 --- /dev/null +++ b/mtr/basic/r/mcol2044_unsigned_dec38_delete-drop-max.result @@ -0,0 +1,13 @@ +create database if not exists test_ranges; +use test_ranges; +drop table if exists t; +create table t(x bigint unsigned) engine=columnstore; +insert into t(x) values (44),(55),(66); +select max_value, min_value from information_schema.columnstore_extents; +max_value min_value +66 44 +delete from t where x=44; +select max_value, min_value from information_schema.columnstore_extents; +max_value min_value +0 -1 +drop database test_ranges; diff --git a/mtr/basic/r/mcol2044_unsigned_dec38_delete-drop-min.result b/mtr/basic/r/mcol2044_unsigned_dec38_delete-drop-min.result new file mode 100644 index 000000000..2d1b3b253 --- /dev/null +++ b/mtr/basic/r/mcol2044_unsigned_dec38_delete-drop-min.result @@ -0,0 +1,13 @@ +create database if not exists test_ranges; +use test_ranges; +drop table if exists t; +create table t(x bigint unsigned) engine=columnstore; +insert into t(x) values (44),(55),(66); +select max_value, min_value from information_schema.columnstore_extents; +max_value min_value +66 44 +delete from t where x=66; +select max_value, min_value from information_schema.columnstore_extents; +max_value min_value +0 -1 +drop database test_ranges; diff --git a/mtr/basic/r/mcol2044_unsigned_dec38_delete-within-range.result b/mtr/basic/r/mcol2044_unsigned_dec38_delete-within-range.result new file mode 100644 index 000000000..8511fc74f --- /dev/null +++ b/mtr/basic/r/mcol2044_unsigned_dec38_delete-within-range.result @@ -0,0 +1,10 @@ +create database if not exists test_ranges; +use test_ranges; +drop table if exists t; +create table t(x bigint unsigned) engine=columnstore; +insert into t(x) values (44),(55),(66); +delete from t where x=55; +select max_value, min_value from information_schema.columnstore_extents; +max_value min_value +66 44 +drop database test_ranges; diff --git a/mtr/basic/r/mcol2044_unsigned_dec38_insert-keeps-invalid-range.result b/mtr/basic/r/mcol2044_unsigned_dec38_insert-keeps-invalid-range.result new file mode 100644 index 000000000..d0cd14269 --- /dev/null +++ b/mtr/basic/r/mcol2044_unsigned_dec38_insert-keeps-invalid-range.result @@ -0,0 +1,11 @@ +create database if not exists test_ranges; +use test_ranges; +drop table if exists t; +create table t(x bigint unsigned) engine=columnstore; +insert into t(x) values (44),(55),(66); +update t set x=65 where x=66; +insert into t(x) values (77), (22); +select max_value, min_value from information_schema.columnstore_extents; +max_value min_value +0 -1 +drop database test_ranges; diff --git a/mtr/basic/r/mcol2044_unsigned_dec38_update-drop-max.result b/mtr/basic/r/mcol2044_unsigned_dec38_update-drop-max.result new file mode 100644 index 000000000..7843ca2ab --- /dev/null +++ b/mtr/basic/r/mcol2044_unsigned_dec38_update-drop-max.result @@ -0,0 +1,10 @@ +create database if not exists test_ranges; +use test_ranges; +drop table if exists t; +create table t(x bigint unsigned) engine=columnstore; +insert into t(x) values (44),(55),(66); +update t set x=65 where x=44; +select max_value, min_value from information_schema.columnstore_extents; +max_value min_value +0 -1 +drop database test_ranges; diff --git a/mtr/basic/r/mcol2044_unsigned_dec38_update-drop-min.result b/mtr/basic/r/mcol2044_unsigned_dec38_update-drop-min.result new file mode 100644 index 000000000..7843ca2ab --- /dev/null +++ b/mtr/basic/r/mcol2044_unsigned_dec38_update-drop-min.result @@ -0,0 +1,10 @@ +create database if not exists test_ranges; +use test_ranges; +drop table if exists t; +create table t(x bigint unsigned) engine=columnstore; +insert into t(x) values (44),(55),(66); +update t set x=65 where x=44; +select max_value, min_value from information_schema.columnstore_extents; +max_value min_value +0 -1 +drop database test_ranges; diff --git a/mtr/basic/r/mcol2044_unsigned_dec38_update-extends-max.result b/mtr/basic/r/mcol2044_unsigned_dec38_update-extends-max.result new file mode 100644 index 000000000..d47d09b8e --- /dev/null +++ b/mtr/basic/r/mcol2044_unsigned_dec38_update-extends-max.result @@ -0,0 +1,10 @@ +create database if not exists test_ranges; +use test_ranges; +drop table if exists t; +create table t(x bigint unsigned) engine=columnstore; +insert into t(x) values (44),(55),(66); +update t set x=77 where x=66; +select max_value, min_value from information_schema.columnstore_extents; +max_value min_value +77 44 +drop database test_ranges; diff --git a/mtr/basic/r/mcol2044_unsigned_dec38_update-extends-min.result b/mtr/basic/r/mcol2044_unsigned_dec38_update-extends-min.result new file mode 100644 index 000000000..8ebafe1e9 --- /dev/null +++ b/mtr/basic/r/mcol2044_unsigned_dec38_update-extends-min.result @@ -0,0 +1,10 @@ +create database if not exists test_ranges; +use test_ranges; +drop table if exists t; +create table t(x bigint unsigned) engine=columnstore; +insert into t(x) values (44),(55),(66); +update t set x=33 where x=44; +select max_value, min_value from information_schema.columnstore_extents; +max_value min_value +66 33 +drop database test_ranges; diff --git a/mtr/basic/r/mcol2044_unsigned_dec38_update-within-range.result b/mtr/basic/r/mcol2044_unsigned_dec38_update-within-range.result new file mode 100644 index 000000000..8a543761d --- /dev/null +++ b/mtr/basic/r/mcol2044_unsigned_dec38_update-within-range.result @@ -0,0 +1,10 @@ +create database if not exists test_ranges; +use test_ranges; +drop table if exists t; +create table t(x bigint unsigned) engine=columnstore; +insert into t(x) values (44),(55),(66); +update t set x=65 where x=55; +select max_value, min_value from information_schema.columnstore_extents; +max_value min_value +66 44 +drop database test_ranges; diff --git a/mtr/basic/r/mcol2044_unsigned_integer_delete-drop-max.result b/mtr/basic/r/mcol2044_unsigned_integer_delete-drop-max.result new file mode 100644 index 000000000..332e2c46b --- /dev/null +++ b/mtr/basic/r/mcol2044_unsigned_integer_delete-drop-max.result @@ -0,0 +1,13 @@ +create database if not exists test_ranges; +use test_ranges; +drop table if exists t; +create table t(x integer unsigned) engine=columnstore; +insert into t(x) values (44),(55),(66); +select max_value, min_value from information_schema.columnstore_extents; +max_value min_value +66 44 +delete from t where x=44; +select max_value, min_value from information_schema.columnstore_extents; +max_value min_value +0 -1 +drop database test_ranges; diff --git a/mtr/basic/r/mcol2044_unsigned_integer_delete-drop-min.result b/mtr/basic/r/mcol2044_unsigned_integer_delete-drop-min.result new file mode 100644 index 000000000..d00e1b11c --- /dev/null +++ b/mtr/basic/r/mcol2044_unsigned_integer_delete-drop-min.result @@ -0,0 +1,13 @@ +create database if not exists test_ranges; +use test_ranges; +drop table if exists t; +create table t(x integer unsigned) engine=columnstore; +insert into t(x) values (44),(55),(66); +select max_value, min_value from information_schema.columnstore_extents; +max_value min_value +66 44 +delete from t where x=66; +select max_value, min_value from information_schema.columnstore_extents; +max_value min_value +0 -1 +drop database test_ranges; diff --git a/mtr/basic/r/mcol2044_unsigned_integer_delete-within-range.result b/mtr/basic/r/mcol2044_unsigned_integer_delete-within-range.result new file mode 100644 index 000000000..d40e4d691 --- /dev/null +++ b/mtr/basic/r/mcol2044_unsigned_integer_delete-within-range.result @@ -0,0 +1,10 @@ +create database if not exists test_ranges; +use test_ranges; +drop table if exists t; +create table t(x integer unsigned) engine=columnstore; +insert into t(x) values (44),(55),(66); +delete from t where x=55; +select max_value, min_value from information_schema.columnstore_extents; +max_value min_value +66 44 +drop database test_ranges; diff --git a/mtr/basic/r/mcol2044_unsigned_integer_insert-keeps-invalid-range.result b/mtr/basic/r/mcol2044_unsigned_integer_insert-keeps-invalid-range.result new file mode 100644 index 000000000..e3ae72e0d --- /dev/null +++ b/mtr/basic/r/mcol2044_unsigned_integer_insert-keeps-invalid-range.result @@ -0,0 +1,11 @@ +create database if not exists test_ranges; +use test_ranges; +drop table if exists t; +create table t(x integer unsigned) engine=columnstore; +insert into t(x) values (44),(55),(66); +update t set x=65 where x=66; +insert into t(x) values (77), (22); +select max_value, min_value from information_schema.columnstore_extents; +max_value min_value +0 -1 +drop database test_ranges; diff --git a/mtr/basic/r/mcol2044_unsigned_integer_update-drop-max.result b/mtr/basic/r/mcol2044_unsigned_integer_update-drop-max.result new file mode 100644 index 000000000..197e60440 --- /dev/null +++ b/mtr/basic/r/mcol2044_unsigned_integer_update-drop-max.result @@ -0,0 +1,10 @@ +create database if not exists test_ranges; +use test_ranges; +drop table if exists t; +create table t(x integer unsigned) engine=columnstore; +insert into t(x) values (44),(55),(66); +update t set x=65 where x=44; +select max_value, min_value from information_schema.columnstore_extents; +max_value min_value +0 -1 +drop database test_ranges; diff --git a/mtr/basic/r/mcol2044_unsigned_integer_update-drop-min.result b/mtr/basic/r/mcol2044_unsigned_integer_update-drop-min.result new file mode 100644 index 000000000..197e60440 --- /dev/null +++ b/mtr/basic/r/mcol2044_unsigned_integer_update-drop-min.result @@ -0,0 +1,10 @@ +create database if not exists test_ranges; +use test_ranges; +drop table if exists t; +create table t(x integer unsigned) engine=columnstore; +insert into t(x) values (44),(55),(66); +update t set x=65 where x=44; +select max_value, min_value from information_schema.columnstore_extents; +max_value min_value +0 -1 +drop database test_ranges; diff --git a/mtr/basic/r/mcol2044_unsigned_integer_update-extends-max.result b/mtr/basic/r/mcol2044_unsigned_integer_update-extends-max.result new file mode 100644 index 000000000..534cf9196 --- /dev/null +++ b/mtr/basic/r/mcol2044_unsigned_integer_update-extends-max.result @@ -0,0 +1,10 @@ +create database if not exists test_ranges; +use test_ranges; +drop table if exists t; +create table t(x integer unsigned) engine=columnstore; +insert into t(x) values (44),(55),(66); +update t set x=77 where x=66; +select max_value, min_value from information_schema.columnstore_extents; +max_value min_value +77 44 +drop database test_ranges; diff --git a/mtr/basic/r/mcol2044_unsigned_integer_update-extends-min.result b/mtr/basic/r/mcol2044_unsigned_integer_update-extends-min.result new file mode 100644 index 000000000..2b2facdee --- /dev/null +++ b/mtr/basic/r/mcol2044_unsigned_integer_update-extends-min.result @@ -0,0 +1,10 @@ +create database if not exists test_ranges; +use test_ranges; +drop table if exists t; +create table t(x integer unsigned) engine=columnstore; +insert into t(x) values (44),(55),(66); +update t set x=33 where x=44; +select max_value, min_value from information_schema.columnstore_extents; +max_value min_value +66 33 +drop database test_ranges; diff --git a/mtr/basic/r/mcol2044_unsigned_integer_update-within-range.result b/mtr/basic/r/mcol2044_unsigned_integer_update-within-range.result new file mode 100644 index 000000000..d07aa90ca --- /dev/null +++ b/mtr/basic/r/mcol2044_unsigned_integer_update-within-range.result @@ -0,0 +1,10 @@ +create database if not exists test_ranges; +use test_ranges; +drop table if exists t; +create table t(x integer unsigned) engine=columnstore; +insert into t(x) values (44),(55),(66); +update t set x=65 where x=55; +select max_value, min_value from information_schema.columnstore_extents; +max_value min_value +66 44 +drop database test_ranges; diff --git a/mtr/basic/r/mcol2044_unsigned_smallint_delete-drop-max.result b/mtr/basic/r/mcol2044_unsigned_smallint_delete-drop-max.result new file mode 100644 index 000000000..ed212de43 --- /dev/null +++ b/mtr/basic/r/mcol2044_unsigned_smallint_delete-drop-max.result @@ -0,0 +1,13 @@ +create database if not exists test_ranges; +use test_ranges; +drop table if exists t; +create table t(x smallint unsigned) engine=columnstore; +insert into t(x) values (44),(55),(66); +select max_value, min_value from information_schema.columnstore_extents; +max_value min_value +66 44 +delete from t where x=44; +select max_value, min_value from information_schema.columnstore_extents; +max_value min_value +0 -1 +drop database test_ranges; diff --git a/mtr/basic/r/mcol2044_unsigned_smallint_delete-drop-min.result b/mtr/basic/r/mcol2044_unsigned_smallint_delete-drop-min.result new file mode 100644 index 000000000..8c101a8a5 --- /dev/null +++ b/mtr/basic/r/mcol2044_unsigned_smallint_delete-drop-min.result @@ -0,0 +1,13 @@ +create database if not exists test_ranges; +use test_ranges; +drop table if exists t; +create table t(x smallint unsigned) engine=columnstore; +insert into t(x) values (44),(55),(66); +select max_value, min_value from information_schema.columnstore_extents; +max_value min_value +66 44 +delete from t where x=66; +select max_value, min_value from information_schema.columnstore_extents; +max_value min_value +0 -1 +drop database test_ranges; diff --git a/mtr/basic/r/mcol2044_unsigned_smallint_delete-within-range.result b/mtr/basic/r/mcol2044_unsigned_smallint_delete-within-range.result new file mode 100644 index 000000000..64c778cb3 --- /dev/null +++ b/mtr/basic/r/mcol2044_unsigned_smallint_delete-within-range.result @@ -0,0 +1,10 @@ +create database if not exists test_ranges; +use test_ranges; +drop table if exists t; +create table t(x smallint unsigned) engine=columnstore; +insert into t(x) values (44),(55),(66); +delete from t where x=55; +select max_value, min_value from information_schema.columnstore_extents; +max_value min_value +66 44 +drop database test_ranges; diff --git a/mtr/basic/r/mcol2044_unsigned_smallint_insert-keeps-invalid-range.result b/mtr/basic/r/mcol2044_unsigned_smallint_insert-keeps-invalid-range.result new file mode 100644 index 000000000..5617a6e09 --- /dev/null +++ b/mtr/basic/r/mcol2044_unsigned_smallint_insert-keeps-invalid-range.result @@ -0,0 +1,11 @@ +create database if not exists test_ranges; +use test_ranges; +drop table if exists t; +create table t(x smallint unsigned) engine=columnstore; +insert into t(x) values (44),(55),(66); +update t set x=65 where x=66; +insert into t(x) values (77), (22); +select max_value, min_value from information_schema.columnstore_extents; +max_value min_value +0 -1 +drop database test_ranges; diff --git a/mtr/basic/r/mcol2044_unsigned_smallint_update-drop-max.result b/mtr/basic/r/mcol2044_unsigned_smallint_update-drop-max.result new file mode 100644 index 000000000..b53124cda --- /dev/null +++ b/mtr/basic/r/mcol2044_unsigned_smallint_update-drop-max.result @@ -0,0 +1,10 @@ +create database if not exists test_ranges; +use test_ranges; +drop table if exists t; +create table t(x smallint unsigned) engine=columnstore; +insert into t(x) values (44),(55),(66); +update t set x=65 where x=44; +select max_value, min_value from information_schema.columnstore_extents; +max_value min_value +0 -1 +drop database test_ranges; diff --git a/mtr/basic/r/mcol2044_unsigned_smallint_update-drop-min.result b/mtr/basic/r/mcol2044_unsigned_smallint_update-drop-min.result new file mode 100644 index 000000000..b53124cda --- /dev/null +++ b/mtr/basic/r/mcol2044_unsigned_smallint_update-drop-min.result @@ -0,0 +1,10 @@ +create database if not exists test_ranges; +use test_ranges; +drop table if exists t; +create table t(x smallint unsigned) engine=columnstore; +insert into t(x) values (44),(55),(66); +update t set x=65 where x=44; +select max_value, min_value from information_schema.columnstore_extents; +max_value min_value +0 -1 +drop database test_ranges; diff --git a/mtr/basic/r/mcol2044_unsigned_smallint_update-extends-max.result b/mtr/basic/r/mcol2044_unsigned_smallint_update-extends-max.result new file mode 100644 index 000000000..ea0092d12 --- /dev/null +++ b/mtr/basic/r/mcol2044_unsigned_smallint_update-extends-max.result @@ -0,0 +1,10 @@ +create database if not exists test_ranges; +use test_ranges; +drop table if exists t; +create table t(x smallint unsigned) engine=columnstore; +insert into t(x) values (44),(55),(66); +update t set x=77 where x=66; +select max_value, min_value from information_schema.columnstore_extents; +max_value min_value +77 44 +drop database test_ranges; diff --git a/mtr/basic/r/mcol2044_unsigned_smallint_update-extends-min.result b/mtr/basic/r/mcol2044_unsigned_smallint_update-extends-min.result new file mode 100644 index 000000000..88e89d845 --- /dev/null +++ b/mtr/basic/r/mcol2044_unsigned_smallint_update-extends-min.result @@ -0,0 +1,10 @@ +create database if not exists test_ranges; +use test_ranges; +drop table if exists t; +create table t(x smallint unsigned) engine=columnstore; +insert into t(x) values (44),(55),(66); +update t set x=33 where x=44; +select max_value, min_value from information_schema.columnstore_extents; +max_value min_value +66 33 +drop database test_ranges; diff --git a/mtr/basic/r/mcol2044_unsigned_smallint_update-within-range.result b/mtr/basic/r/mcol2044_unsigned_smallint_update-within-range.result new file mode 100644 index 000000000..f8aa1a15d --- /dev/null +++ b/mtr/basic/r/mcol2044_unsigned_smallint_update-within-range.result @@ -0,0 +1,10 @@ +create database if not exists test_ranges; +use test_ranges; +drop table if exists t; +create table t(x smallint unsigned) engine=columnstore; +insert into t(x) values (44),(55),(66); +update t set x=65 where x=55; +select max_value, min_value from information_schema.columnstore_extents; +max_value min_value +66 44 +drop database test_ranges; diff --git a/mtr/basic/r/mcol2044_unsigned_tinyint_delete-drop-max.result b/mtr/basic/r/mcol2044_unsigned_tinyint_delete-drop-max.result new file mode 100644 index 000000000..bf0667b46 --- /dev/null +++ b/mtr/basic/r/mcol2044_unsigned_tinyint_delete-drop-max.result @@ -0,0 +1,13 @@ +create database if not exists test_ranges; +use test_ranges; +drop table if exists t; +create table t(x tinyint unsigned) engine=columnstore; +insert into t(x) values (44),(55),(66); +select max_value, min_value from information_schema.columnstore_extents; +max_value min_value +66 44 +delete from t where x=44; +select max_value, min_value from information_schema.columnstore_extents; +max_value min_value +0 -1 +drop database test_ranges; diff --git a/mtr/basic/r/mcol2044_unsigned_tinyint_delete-drop-min.result b/mtr/basic/r/mcol2044_unsigned_tinyint_delete-drop-min.result new file mode 100644 index 000000000..28ef5e6ef --- /dev/null +++ b/mtr/basic/r/mcol2044_unsigned_tinyint_delete-drop-min.result @@ -0,0 +1,13 @@ +create database if not exists test_ranges; +use test_ranges; +drop table if exists t; +create table t(x tinyint unsigned) engine=columnstore; +insert into t(x) values (44),(55),(66); +select max_value, min_value from information_schema.columnstore_extents; +max_value min_value +66 44 +delete from t where x=66; +select max_value, min_value from information_schema.columnstore_extents; +max_value min_value +0 -1 +drop database test_ranges; diff --git a/mtr/basic/r/mcol2044_unsigned_tinyint_delete-within-range.result b/mtr/basic/r/mcol2044_unsigned_tinyint_delete-within-range.result new file mode 100644 index 000000000..d35016baa --- /dev/null +++ b/mtr/basic/r/mcol2044_unsigned_tinyint_delete-within-range.result @@ -0,0 +1,10 @@ +create database if not exists test_ranges; +use test_ranges; +drop table if exists t; +create table t(x tinyint unsigned) engine=columnstore; +insert into t(x) values (44),(55),(66); +delete from t where x=55; +select max_value, min_value from information_schema.columnstore_extents; +max_value min_value +66 44 +drop database test_ranges; diff --git a/mtr/basic/r/mcol2044_unsigned_tinyint_insert-keeps-invalid-range.result b/mtr/basic/r/mcol2044_unsigned_tinyint_insert-keeps-invalid-range.result new file mode 100644 index 000000000..c65966fc2 --- /dev/null +++ b/mtr/basic/r/mcol2044_unsigned_tinyint_insert-keeps-invalid-range.result @@ -0,0 +1,11 @@ +create database if not exists test_ranges; +use test_ranges; +drop table if exists t; +create table t(x tinyint unsigned) engine=columnstore; +insert into t(x) values (44),(55),(66); +update t set x=65 where x=66; +insert into t(x) values (77), (22); +select max_value, min_value from information_schema.columnstore_extents; +max_value min_value +0 -1 +drop database test_ranges; diff --git a/mtr/basic/r/mcol2044_unsigned_tinyint_update-drop-max.result b/mtr/basic/r/mcol2044_unsigned_tinyint_update-drop-max.result new file mode 100644 index 000000000..7f4215af4 --- /dev/null +++ b/mtr/basic/r/mcol2044_unsigned_tinyint_update-drop-max.result @@ -0,0 +1,10 @@ +create database if not exists test_ranges; +use test_ranges; +drop table if exists t; +create table t(x tinyint unsigned) engine=columnstore; +insert into t(x) values (44),(55),(66); +update t set x=65 where x=44; +select max_value, min_value from information_schema.columnstore_extents; +max_value min_value +0 -1 +drop database test_ranges; diff --git a/mtr/basic/r/mcol2044_unsigned_tinyint_update-drop-min.result b/mtr/basic/r/mcol2044_unsigned_tinyint_update-drop-min.result new file mode 100644 index 000000000..7f4215af4 --- /dev/null +++ b/mtr/basic/r/mcol2044_unsigned_tinyint_update-drop-min.result @@ -0,0 +1,10 @@ +create database if not exists test_ranges; +use test_ranges; +drop table if exists t; +create table t(x tinyint unsigned) engine=columnstore; +insert into t(x) values (44),(55),(66); +update t set x=65 where x=44; +select max_value, min_value from information_schema.columnstore_extents; +max_value min_value +0 -1 +drop database test_ranges; diff --git a/mtr/basic/r/mcol2044_unsigned_tinyint_update-extends-max.result b/mtr/basic/r/mcol2044_unsigned_tinyint_update-extends-max.result new file mode 100644 index 000000000..745536ac6 --- /dev/null +++ b/mtr/basic/r/mcol2044_unsigned_tinyint_update-extends-max.result @@ -0,0 +1,10 @@ +create database if not exists test_ranges; +use test_ranges; +drop table if exists t; +create table t(x tinyint unsigned) engine=columnstore; +insert into t(x) values (44),(55),(66); +update t set x=77 where x=66; +select max_value, min_value from information_schema.columnstore_extents; +max_value min_value +77 44 +drop database test_ranges; diff --git a/mtr/basic/r/mcol2044_unsigned_tinyint_update-extends-min.result b/mtr/basic/r/mcol2044_unsigned_tinyint_update-extends-min.result new file mode 100644 index 000000000..68e455e05 --- /dev/null +++ b/mtr/basic/r/mcol2044_unsigned_tinyint_update-extends-min.result @@ -0,0 +1,10 @@ +create database if not exists test_ranges; +use test_ranges; +drop table if exists t; +create table t(x tinyint unsigned) engine=columnstore; +insert into t(x) values (44),(55),(66); +update t set x=33 where x=44; +select max_value, min_value from information_schema.columnstore_extents; +max_value min_value +66 33 +drop database test_ranges; diff --git a/mtr/basic/r/mcol2044_unsigned_tinyint_update-within-range.result b/mtr/basic/r/mcol2044_unsigned_tinyint_update-within-range.result new file mode 100644 index 000000000..7b32b64ec --- /dev/null +++ b/mtr/basic/r/mcol2044_unsigned_tinyint_update-within-range.result @@ -0,0 +1,10 @@ +create database if not exists test_ranges; +use test_ranges; +drop table if exists t; +create table t(x tinyint unsigned) engine=columnstore; +insert into t(x) values (44),(55),(66); +update t set x=65 where x=55; +select max_value, min_value from information_schema.columnstore_extents; +max_value min_value +66 44 +drop database test_ranges; diff --git a/mtr/basic/t/mcol2044_signed_bigint_delete-drop-max.test b/mtr/basic/t/mcol2044_signed_bigint_delete-drop-max.test new file mode 100644 index 000000000..98dd469e7 --- /dev/null +++ b/mtr/basic/t/mcol2044_signed_bigint_delete-drop-max.test @@ -0,0 +1,13 @@ +# tests updates that sets invalid range when we set value at max boundary that is less than max. +--disable_warnings +create database if not exists test_ranges; +use test_ranges; +drop table if exists t; +--enable_warnings +create table t(x bigint) engine=columnstore; +insert into t(x) values (44),(55),(66); # range must be 44..66. +select max_value, min_value from information_schema.columnstore_extents; +delete from t where x=44; # range must drop to invalid +select max_value, min_value from information_schema.columnstore_extents; +drop database test_ranges; + diff --git a/mtr/basic/t/mcol2044_signed_bigint_delete-drop-min.test b/mtr/basic/t/mcol2044_signed_bigint_delete-drop-min.test new file mode 100644 index 000000000..f469a3850 --- /dev/null +++ b/mtr/basic/t/mcol2044_signed_bigint_delete-drop-min.test @@ -0,0 +1,13 @@ +# tests updates that range when we updating min value to value that is bigger than min. +--disable_warnings +create database if not exists test_ranges; +use test_ranges; +drop table if exists t; +--enable_warnings +create table t(x bigint) engine=columnstore; +insert into t(x) values (44),(55),(66); # range must be 44..66. +select max_value, min_value from information_schema.columnstore_extents; +delete from t where x=66; # range must be invalid now. +select max_value, min_value from information_schema.columnstore_extents; +drop database test_ranges; + diff --git a/mtr/basic/t/mcol2044_signed_bigint_delete-within-range.test b/mtr/basic/t/mcol2044_signed_bigint_delete-within-range.test new file mode 100644 index 000000000..4082b1bfd --- /dev/null +++ b/mtr/basic/t/mcol2044_signed_bigint_delete-within-range.test @@ -0,0 +1,11 @@ +# tests updates within range. +--disable_warnings +create database if not exists test_ranges; +use test_ranges; +drop table if exists t; +--enable_warnings +create table t(x bigint) engine=columnstore; +insert into t(x) values (44),(55),(66); # range must be 44..66. +delete from t where x=55; # range must stay 44..66. +select max_value, min_value from information_schema.columnstore_extents; +drop database test_ranges; diff --git a/mtr/basic/t/mcol2044_signed_bigint_insert-keeps-invalid-range.test b/mtr/basic/t/mcol2044_signed_bigint_insert-keeps-invalid-range.test new file mode 100644 index 000000000..933b00ac7 --- /dev/null +++ b/mtr/basic/t/mcol2044_signed_bigint_insert-keeps-invalid-range.test @@ -0,0 +1,12 @@ +# tests updates within range. +--disable_warnings +create database if not exists test_ranges; +use test_ranges; +drop table if exists t; +--enable_warnings +create table t(x bigint) engine=columnstore; +insert into t(x) values (44),(55),(66); # range must be 44..66. +update t set x=65 where x=66; # range must drop to invalid +insert into t(x) values (77), (22); # range must stay invalid. +select max_value, min_value from information_schema.columnstore_extents; +drop database test_ranges; diff --git a/mtr/basic/t/mcol2044_signed_bigint_update-drop-max.test b/mtr/basic/t/mcol2044_signed_bigint_update-drop-max.test new file mode 100644 index 000000000..9836c0d2e --- /dev/null +++ b/mtr/basic/t/mcol2044_signed_bigint_update-drop-max.test @@ -0,0 +1,11 @@ +# tests updates that sets invalid range when we set value at max boundary that is less than max. +--disable_warnings +create database if not exists test_ranges; +use test_ranges; +drop table if exists t; +--enable_warnings +create table t(x bigint) engine=columnstore; +insert into t(x) values (44),(55),(66); # range must be 44..66. +update t set x=65 where x=44; # range must drop to invalid +select max_value, min_value from information_schema.columnstore_extents; +drop database test_ranges; diff --git a/mtr/basic/t/mcol2044_signed_bigint_update-drop-min.test b/mtr/basic/t/mcol2044_signed_bigint_update-drop-min.test new file mode 100644 index 000000000..683c57770 --- /dev/null +++ b/mtr/basic/t/mcol2044_signed_bigint_update-drop-min.test @@ -0,0 +1,12 @@ +# tests updates that range when we updating min value to value that is bigger than min. +--disable_warnings +create database if not exists test_ranges; +use test_ranges; +drop table if exists t; +--enable_warnings +create table t(x bigint) engine=columnstore; +insert into t(x) values (44),(55),(66); # range must be 44..66. +update t set x=65 where x=44; # range must be invalid now. + +select max_value, min_value from information_schema.columnstore_extents; +drop database test_ranges; diff --git a/mtr/basic/t/mcol2044_signed_bigint_update-extends-max.test b/mtr/basic/t/mcol2044_signed_bigint_update-extends-max.test new file mode 100644 index 000000000..0da9b6b9e --- /dev/null +++ b/mtr/basic/t/mcol2044_signed_bigint_update-extends-max.test @@ -0,0 +1,11 @@ +# tests updates that extend max range, for values at max. +--disable_warnings +create database if not exists test_ranges; +use test_ranges; +drop table if exists t; +--enable_warnings +create table t(x bigint) engine=columnstore; +insert into t(x) values (44),(55),(66); # range must be 44..66. +update t set x=77 where x=66; # range must be 44..77 +select max_value, min_value from information_schema.columnstore_extents; +drop database test_ranges; diff --git a/mtr/basic/t/mcol2044_signed_bigint_update-extends-min.test b/mtr/basic/t/mcol2044_signed_bigint_update-extends-min.test new file mode 100644 index 000000000..ce4c94508 --- /dev/null +++ b/mtr/basic/t/mcol2044_signed_bigint_update-extends-min.test @@ -0,0 +1,11 @@ +# tests updates that extend range to new min value. +--disable_warnings +create database if not exists test_ranges; +use test_ranges; +drop table if exists t; +--enable_warnings +create table t(x bigint) engine=columnstore; +insert into t(x) values (44),(55),(66); # range must be 44..66. +update t set x=33 where x=44; # range must be 33..66. +select max_value, min_value from information_schema.columnstore_extents; +drop database test_ranges; diff --git a/mtr/basic/t/mcol2044_signed_bigint_update-within-range.test b/mtr/basic/t/mcol2044_signed_bigint_update-within-range.test new file mode 100644 index 000000000..26d2d2873 --- /dev/null +++ b/mtr/basic/t/mcol2044_signed_bigint_update-within-range.test @@ -0,0 +1,11 @@ +# tests updates within range. +--disable_warnings +create database if not exists test_ranges; +use test_ranges; +drop table if exists t; +--enable_warnings +create table t(x bigint) engine=columnstore; +insert into t(x) values (44),(55),(66); # range must be 44..66. +update t set x=65 where x=55; # range must stay 44..66. +select max_value, min_value from information_schema.columnstore_extents; +drop database test_ranges; diff --git a/mtr/basic/t/mcol2044_signed_dec38_delete-drop-max.test b/mtr/basic/t/mcol2044_signed_dec38_delete-drop-max.test new file mode 100644 index 000000000..6c46eb37f --- /dev/null +++ b/mtr/basic/t/mcol2044_signed_dec38_delete-drop-max.test @@ -0,0 +1,13 @@ +# tests updates that sets invalid range when we set value at max boundary that is less than max. +--disable_warnings +create database if not exists test_ranges; +use test_ranges; +drop table if exists t; +--enable_warnings +create table t(x decimal(38)) engine=columnstore; +insert into t(x) values (44),(55),(66); # range must be 44..66. +select max_value, min_value from information_schema.columnstore_extents; +delete from t where x=44; # range must drop to invalid +select max_value, min_value from information_schema.columnstore_extents; +drop database test_ranges; + diff --git a/mtr/basic/t/mcol2044_signed_dec38_delete-drop-min.test b/mtr/basic/t/mcol2044_signed_dec38_delete-drop-min.test new file mode 100644 index 000000000..130372c1b --- /dev/null +++ b/mtr/basic/t/mcol2044_signed_dec38_delete-drop-min.test @@ -0,0 +1,13 @@ +# tests updates that range when we updating min value to value that is bigger than min. +--disable_warnings +create database if not exists test_ranges; +use test_ranges; +drop table if exists t; +--enable_warnings +create table t(x decimal(38)) engine=columnstore; +insert into t(x) values (44),(55),(66); # range must be 44..66. +select max_value, min_value from information_schema.columnstore_extents; +delete from t where x=66; # range must be invalid now. +select max_value, min_value from information_schema.columnstore_extents; +drop database test_ranges; + diff --git a/mtr/basic/t/mcol2044_signed_dec38_delete-within-range.test b/mtr/basic/t/mcol2044_signed_dec38_delete-within-range.test new file mode 100644 index 000000000..d1d2632ed --- /dev/null +++ b/mtr/basic/t/mcol2044_signed_dec38_delete-within-range.test @@ -0,0 +1,11 @@ +# tests updates within range. +--disable_warnings +create database if not exists test_ranges; +use test_ranges; +drop table if exists t; +--enable_warnings +create table t(x decimal(38)) engine=columnstore; +insert into t(x) values (44),(55),(66); # range must be 44..66. +delete from t where x=55; # range must stay 44..66. +select max_value, min_value from information_schema.columnstore_extents; +drop database test_ranges; diff --git a/mtr/basic/t/mcol2044_signed_dec38_insert-keeps-invalid-range.test b/mtr/basic/t/mcol2044_signed_dec38_insert-keeps-invalid-range.test new file mode 100644 index 000000000..5cac571a7 --- /dev/null +++ b/mtr/basic/t/mcol2044_signed_dec38_insert-keeps-invalid-range.test @@ -0,0 +1,12 @@ +# tests updates within range. +--disable_warnings +create database if not exists test_ranges; +use test_ranges; +drop table if exists t; +--enable_warnings +create table t(x decimal(38)) engine=columnstore; +insert into t(x) values (44),(55),(66); # range must be 44..66. +update t set x=65 where x=66; # range must drop to invalid +insert into t(x) values (77), (22); # range must stay invalid. +select max_value, min_value from information_schema.columnstore_extents; +drop database test_ranges; diff --git a/mtr/basic/t/mcol2044_signed_dec38_update-drop-max.test b/mtr/basic/t/mcol2044_signed_dec38_update-drop-max.test new file mode 100644 index 000000000..1b25c1035 --- /dev/null +++ b/mtr/basic/t/mcol2044_signed_dec38_update-drop-max.test @@ -0,0 +1,11 @@ +# tests updates that sets invalid range when we set value at max boundary that is less than max. +--disable_warnings +create database if not exists test_ranges; +use test_ranges; +drop table if exists t; +--enable_warnings +create table t(x decimal(38)) engine=columnstore; +insert into t(x) values (44),(55),(66); # range must be 44..66. +update t set x=65 where x=44; # range must drop to invalid +select max_value, min_value from information_schema.columnstore_extents; +drop database test_ranges; diff --git a/mtr/basic/t/mcol2044_signed_dec38_update-drop-min.test b/mtr/basic/t/mcol2044_signed_dec38_update-drop-min.test new file mode 100644 index 000000000..62311a04c --- /dev/null +++ b/mtr/basic/t/mcol2044_signed_dec38_update-drop-min.test @@ -0,0 +1,12 @@ +# tests updates that range when we updating min value to value that is bigger than min. +--disable_warnings +create database if not exists test_ranges; +use test_ranges; +drop table if exists t; +--enable_warnings +create table t(x decimal(38)) engine=columnstore; +insert into t(x) values (44),(55),(66); # range must be 44..66. +update t set x=65 where x=44; # range must be invalid now. + +select max_value, min_value from information_schema.columnstore_extents; +drop database test_ranges; diff --git a/mtr/basic/t/mcol2044_signed_dec38_update-extends-max.test b/mtr/basic/t/mcol2044_signed_dec38_update-extends-max.test new file mode 100644 index 000000000..c00ecbe37 --- /dev/null +++ b/mtr/basic/t/mcol2044_signed_dec38_update-extends-max.test @@ -0,0 +1,11 @@ +# tests updates that extend max range, for values at max. +--disable_warnings +create database if not exists test_ranges; +use test_ranges; +drop table if exists t; +--enable_warnings +create table t(x decimal(38)) engine=columnstore; +insert into t(x) values (44),(55),(66); # range must be 44..66. +update t set x=77 where x=66; # range must be 44..77 +select max_value, min_value from information_schema.columnstore_extents; +drop database test_ranges; diff --git a/mtr/basic/t/mcol2044_signed_dec38_update-extends-min.test b/mtr/basic/t/mcol2044_signed_dec38_update-extends-min.test new file mode 100644 index 000000000..2d253e36a --- /dev/null +++ b/mtr/basic/t/mcol2044_signed_dec38_update-extends-min.test @@ -0,0 +1,11 @@ +# tests updates that extend range to new min value. +--disable_warnings +create database if not exists test_ranges; +use test_ranges; +drop table if exists t; +--enable_warnings +create table t(x decimal(38)) engine=columnstore; +insert into t(x) values (44),(55),(66); # range must be 44..66. +update t set x=33 where x=44; # range must be 33..66. +select max_value, min_value from information_schema.columnstore_extents; +drop database test_ranges; diff --git a/mtr/basic/t/mcol2044_signed_dec38_update-within-range.test b/mtr/basic/t/mcol2044_signed_dec38_update-within-range.test new file mode 100644 index 000000000..615d7c2ff --- /dev/null +++ b/mtr/basic/t/mcol2044_signed_dec38_update-within-range.test @@ -0,0 +1,11 @@ +# tests updates within range. +--disable_warnings +create database if not exists test_ranges; +use test_ranges; +drop table if exists t; +--enable_warnings +create table t(x decimal(38)) engine=columnstore; +insert into t(x) values (44),(55),(66); # range must be 44..66. +update t set x=65 where x=55; # range must stay 44..66. +select max_value, min_value from information_schema.columnstore_extents; +drop database test_ranges; diff --git a/mtr/basic/t/mcol2044_signed_integer_delete-drop-max.test b/mtr/basic/t/mcol2044_signed_integer_delete-drop-max.test new file mode 100644 index 000000000..cc4d7d3ed --- /dev/null +++ b/mtr/basic/t/mcol2044_signed_integer_delete-drop-max.test @@ -0,0 +1,13 @@ +# tests updates that sets invalid range when we set value at max boundary that is less than max. +--disable_warnings +create database if not exists test_ranges; +use test_ranges; +drop table if exists t; +--enable_warnings +create table t(x integer) engine=columnstore; +insert into t(x) values (44),(55),(66); # range must be 44..66. +select max_value, min_value from information_schema.columnstore_extents; +delete from t where x=44; # range must drop to invalid +select max_value, min_value from information_schema.columnstore_extents; +drop database test_ranges; + diff --git a/mtr/basic/t/mcol2044_signed_integer_delete-drop-min.test b/mtr/basic/t/mcol2044_signed_integer_delete-drop-min.test new file mode 100644 index 000000000..334bcf3c1 --- /dev/null +++ b/mtr/basic/t/mcol2044_signed_integer_delete-drop-min.test @@ -0,0 +1,12 @@ +# tests updates that range when we updating min value to value that is bigger than min. +--disable_warnings +create database if not exists test_ranges; +use test_ranges; +drop table if exists t; +--enable_warnings +create table t(x integer) engine=columnstore; +insert into t(x) values (44),(55),(66); # range must be 44..66. +select max_value, min_value from information_schema.columnstore_extents; +delete from t where x=66; # range must be invalid now. +select max_value, min_value from information_schema.columnstore_extents; +drop database test_ranges; diff --git a/mtr/basic/t/mcol2044_signed_integer_delete-within-range.test b/mtr/basic/t/mcol2044_signed_integer_delete-within-range.test new file mode 100644 index 000000000..560b645bf --- /dev/null +++ b/mtr/basic/t/mcol2044_signed_integer_delete-within-range.test @@ -0,0 +1,11 @@ +# tests updates within range. +--disable_warnings +create database if not exists test_ranges; +use test_ranges; +drop table if exists t; +--enable_warnings +create table t(x integer) engine=columnstore; +insert into t(x) values (44),(55),(66); # range must be 44..66. +delete from t where x=55; # range must stay 44..66. +select max_value, min_value from information_schema.columnstore_extents; +drop database test_ranges; diff --git a/mtr/basic/t/mcol2044_signed_integer_insert-keeps-invalid-range.test b/mtr/basic/t/mcol2044_signed_integer_insert-keeps-invalid-range.test new file mode 100644 index 000000000..00b1aff49 --- /dev/null +++ b/mtr/basic/t/mcol2044_signed_integer_insert-keeps-invalid-range.test @@ -0,0 +1,12 @@ +# tests updates within range. +--disable_warnings +create database if not exists test_ranges; +use test_ranges; +drop table if exists t; +--enable_warnings +create table t(x integer) engine=columnstore; +insert into t(x) values (44),(55),(66); # range must be 44..66. +update t set x=65 where x=66; # range must drop to invalid +insert into t(x) values (77), (22); # range must stay invalid. +select max_value, min_value from information_schema.columnstore_extents; +drop database test_ranges; diff --git a/mtr/basic/t/mcol2044_signed_integer_update-drop-max.test b/mtr/basic/t/mcol2044_signed_integer_update-drop-max.test new file mode 100644 index 000000000..7247534a0 --- /dev/null +++ b/mtr/basic/t/mcol2044_signed_integer_update-drop-max.test @@ -0,0 +1,11 @@ +# tests updates that sets invalid range when we set value at max boundary that is less than max. +--disable_warnings +create database if not exists test_ranges; +use test_ranges; +drop table if exists t; +--enable_warnings +create table t(x integer) engine=columnstore; +insert into t(x) values (44),(55),(66); # range must be 44..66. +update t set x=65 where x=44; # range must drop to invalid +select max_value, min_value from information_schema.columnstore_extents; +drop database test_ranges; diff --git a/mtr/basic/t/mcol2044_signed_integer_update-drop-min.test b/mtr/basic/t/mcol2044_signed_integer_update-drop-min.test new file mode 100644 index 000000000..c99208dd8 --- /dev/null +++ b/mtr/basic/t/mcol2044_signed_integer_update-drop-min.test @@ -0,0 +1,12 @@ +# tests updates that range when we updating min value to value that is bigger than min. +--disable_warnings +create database if not exists test_ranges; +use test_ranges; +drop table if exists t; +--enable_warnings +create table t(x integer) engine=columnstore; +insert into t(x) values (44),(55),(66); # range must be 44..66. +update t set x=65 where x=44; # range must be invalid now. + +select max_value, min_value from information_schema.columnstore_extents; +drop database test_ranges; diff --git a/mtr/basic/t/mcol2044_signed_integer_update-extends-max.test b/mtr/basic/t/mcol2044_signed_integer_update-extends-max.test new file mode 100644 index 000000000..0c668eb1a --- /dev/null +++ b/mtr/basic/t/mcol2044_signed_integer_update-extends-max.test @@ -0,0 +1,11 @@ +# tests updates that extend max range, for values at max. +--disable_warnings +create database if not exists test_ranges; +use test_ranges; +drop table if exists t; +--enable_warnings +create table t(x integer) engine=columnstore; +insert into t(x) values (44),(55),(66); # range must be 44..66. +update t set x=77 where x=66; # range must be 44..77 +select max_value, min_value from information_schema.columnstore_extents; +drop database test_ranges; diff --git a/mtr/basic/t/mcol2044_signed_integer_update-extends-min.test b/mtr/basic/t/mcol2044_signed_integer_update-extends-min.test new file mode 100644 index 000000000..1ddb11261 --- /dev/null +++ b/mtr/basic/t/mcol2044_signed_integer_update-extends-min.test @@ -0,0 +1,11 @@ +# tests updates that extend range to new min value. +--disable_warnings +create database if not exists test_ranges; +use test_ranges; +drop table if exists t; +--enable_warnings +create table t(x integer) engine=columnstore; +insert into t(x) values (44),(55),(66); # range must be 44..66. +update t set x=33 where x=44; # range must be 33..66. +select max_value, min_value from information_schema.columnstore_extents; +drop database test_ranges; diff --git a/mtr/basic/t/mcol2044_signed_integer_update-within-range.test b/mtr/basic/t/mcol2044_signed_integer_update-within-range.test new file mode 100644 index 000000000..e7e7e869f --- /dev/null +++ b/mtr/basic/t/mcol2044_signed_integer_update-within-range.test @@ -0,0 +1,11 @@ +# tests updates within range. +--disable_warnings +create database if not exists test_ranges; +use test_ranges; +drop table if exists t; +--enable_warnings +create table t(x integer) engine=columnstore; +insert into t(x) values (44),(55),(66); # range must be 44..66. +update t set x=65 where x=55; # range must stay 44..66. +select max_value, min_value from information_schema.columnstore_extents; +drop database test_ranges; diff --git a/mtr/basic/t/mcol2044_signed_smallint_delete-drop-max.test b/mtr/basic/t/mcol2044_signed_smallint_delete-drop-max.test new file mode 100644 index 000000000..ae0fd415d --- /dev/null +++ b/mtr/basic/t/mcol2044_signed_smallint_delete-drop-max.test @@ -0,0 +1,12 @@ +# tests updates that sets invalid range when we set value at max boundary that is less than max. +--disable_warnings +create database if not exists test_ranges; +use test_ranges; +drop table if exists t; +--enable_warnings +create table t(x smallint) engine=columnstore; +insert into t(x) values (44),(55),(66); # range must be 44..66. +select max_value, min_value from information_schema.columnstore_extents; +delete from t where x=44; # range must drop to invalid +select max_value, min_value from information_schema.columnstore_extents; +drop database test_ranges; diff --git a/mtr/basic/t/mcol2044_signed_smallint_delete-drop-min.test b/mtr/basic/t/mcol2044_signed_smallint_delete-drop-min.test new file mode 100644 index 000000000..831d47be7 --- /dev/null +++ b/mtr/basic/t/mcol2044_signed_smallint_delete-drop-min.test @@ -0,0 +1,12 @@ +# tests updates that range when we updating min value to value that is bigger than min. +--disable_warnings +create database if not exists test_ranges; +use test_ranges; +drop table if exists t; +--enable_warnings +create table t(x smallint) engine=columnstore; +insert into t(x) values (44),(55),(66); # range must be 44..66. +select max_value, min_value from information_schema.columnstore_extents; +delete from t where x=66; # range must be invalid now. +select max_value, min_value from information_schema.columnstore_extents; +drop database test_ranges; diff --git a/mtr/basic/t/mcol2044_signed_smallint_delete-within-range.test b/mtr/basic/t/mcol2044_signed_smallint_delete-within-range.test new file mode 100644 index 000000000..c4158b78f --- /dev/null +++ b/mtr/basic/t/mcol2044_signed_smallint_delete-within-range.test @@ -0,0 +1,11 @@ +# tests updates within range. +--disable_warnings +create database if not exists test_ranges; +use test_ranges; +drop table if exists t; +--enable_warnings +create table t(x smallint) engine=columnstore; +insert into t(x) values (44),(55),(66); # range must be 44..66. +delete from t where x=55; # range must stay 44..66. +select max_value, min_value from information_schema.columnstore_extents; +drop database test_ranges; diff --git a/mtr/basic/t/mcol2044_signed_smallint_insert-keeps-invalid-range.test b/mtr/basic/t/mcol2044_signed_smallint_insert-keeps-invalid-range.test new file mode 100644 index 000000000..5b50e10df --- /dev/null +++ b/mtr/basic/t/mcol2044_signed_smallint_insert-keeps-invalid-range.test @@ -0,0 +1,12 @@ +# tests updates within range. +--disable_warnings +create database if not exists test_ranges; +use test_ranges; +drop table if exists t; +--enable_warnings +create table t(x smallint) engine=columnstore; +insert into t(x) values (44),(55),(66); # range must be 44..66. +update t set x=65 where x=66; # range must drop to invalid +insert into t(x) values (77), (22); # range must stay invalid. +select max_value, min_value from information_schema.columnstore_extents; +drop database test_ranges; diff --git a/mtr/basic/t/mcol2044_signed_smallint_update-drop-max.test b/mtr/basic/t/mcol2044_signed_smallint_update-drop-max.test new file mode 100644 index 000000000..74df9e6e7 --- /dev/null +++ b/mtr/basic/t/mcol2044_signed_smallint_update-drop-max.test @@ -0,0 +1,11 @@ +# tests updates that sets invalid range when we set value at max boundary that is less than max. +--disable_warnings +create database if not exists test_ranges; +use test_ranges; +drop table if exists t; +--enable_warnings +create table t(x smallint) engine=columnstore; +insert into t(x) values (44),(55),(66); # range must be 44..66. +update t set x=65 where x=44; # range must drop to invalid +select max_value, min_value from information_schema.columnstore_extents; +drop database test_ranges; diff --git a/mtr/basic/t/mcol2044_signed_smallint_update-drop-min.test b/mtr/basic/t/mcol2044_signed_smallint_update-drop-min.test new file mode 100644 index 000000000..f71bcd61f --- /dev/null +++ b/mtr/basic/t/mcol2044_signed_smallint_update-drop-min.test @@ -0,0 +1,12 @@ +# tests updates that range when we updating min value to value that is bigger than min. +--disable_warnings +create database if not exists test_ranges; +use test_ranges; +drop table if exists t; +--enable_warnings +create table t(x smallint) engine=columnstore; +insert into t(x) values (44),(55),(66); # range must be 44..66. +update t set x=65 where x=44; # range must be invalid now. + +select max_value, min_value from information_schema.columnstore_extents; +drop database test_ranges; diff --git a/mtr/basic/t/mcol2044_signed_smallint_update-extends-max.test b/mtr/basic/t/mcol2044_signed_smallint_update-extends-max.test new file mode 100644 index 000000000..66be99c8d --- /dev/null +++ b/mtr/basic/t/mcol2044_signed_smallint_update-extends-max.test @@ -0,0 +1,11 @@ +# tests updates that extend max range, for values at max. +--disable_warnings +create database if not exists test_ranges; +use test_ranges; +drop table if exists t; +--enable_warnings +create table t(x smallint) engine=columnstore; +insert into t(x) values (44),(55),(66); # range must be 44..66. +update t set x=77 where x=66; # range must be 44..77 +select max_value, min_value from information_schema.columnstore_extents; +drop database test_ranges; diff --git a/mtr/basic/t/mcol2044_signed_smallint_update-extends-min.test b/mtr/basic/t/mcol2044_signed_smallint_update-extends-min.test new file mode 100644 index 000000000..8278bf405 --- /dev/null +++ b/mtr/basic/t/mcol2044_signed_smallint_update-extends-min.test @@ -0,0 +1,11 @@ +# tests updates that extend range to new min value. +--disable_warnings +create database if not exists test_ranges; +use test_ranges; +drop table if exists t; +--enable_warnings +create table t(x smallint) engine=columnstore; +insert into t(x) values (44),(55),(66); # range must be 44..66. +update t set x=33 where x=44; # range must be 33..66. +select max_value, min_value from information_schema.columnstore_extents; +drop database test_ranges; diff --git a/mtr/basic/t/mcol2044_signed_smallint_update-within-range.test b/mtr/basic/t/mcol2044_signed_smallint_update-within-range.test new file mode 100644 index 000000000..5ceb7395e --- /dev/null +++ b/mtr/basic/t/mcol2044_signed_smallint_update-within-range.test @@ -0,0 +1,11 @@ +# tests updates within range. +--disable_warnings +create database if not exists test_ranges; +use test_ranges; +drop table if exists t; +--enable_warnings +create table t(x smallint) engine=columnstore; +insert into t(x) values (44),(55),(66); # range must be 44..66. +update t set x=65 where x=55; # range must stay 44..66. +select max_value, min_value from information_schema.columnstore_extents; +drop database test_ranges; diff --git a/mtr/basic/t/mcol2044_signed_tinyint_delete-drop-max.test b/mtr/basic/t/mcol2044_signed_tinyint_delete-drop-max.test new file mode 100644 index 000000000..b4870cab9 --- /dev/null +++ b/mtr/basic/t/mcol2044_signed_tinyint_delete-drop-max.test @@ -0,0 +1,12 @@ +# tests updates that sets invalid range when we set value at max boundary that is less than max. +--disable_warnings +create database if not exists test_ranges; +use test_ranges; +drop table if exists t; +--enable_warnings +create table t(x tinyint) engine=columnstore; +insert into t(x) values (44),(55),(66); # range must be 44..66. +select max_value, min_value from information_schema.columnstore_extents; +delete from t where x=44; # range must drop to invalid +select max_value, min_value from information_schema.columnstore_extents; +drop database test_ranges; diff --git a/mtr/basic/t/mcol2044_signed_tinyint_delete-drop-min.test b/mtr/basic/t/mcol2044_signed_tinyint_delete-drop-min.test new file mode 100644 index 000000000..758b45ef1 --- /dev/null +++ b/mtr/basic/t/mcol2044_signed_tinyint_delete-drop-min.test @@ -0,0 +1,12 @@ +# tests updates that range when we updating min value to value that is bigger than min. +--disable_warnings +create database if not exists test_ranges; +use test_ranges; +drop table if exists t; +--enable_warnings +create table t(x tinyint) engine=columnstore; +insert into t(x) values (44),(55),(66); # range must be 44..66. +select max_value, min_value from information_schema.columnstore_extents; +delete from t where x=66; # range must be invalid now. +select max_value, min_value from information_schema.columnstore_extents; +drop database test_ranges; diff --git a/mtr/basic/t/mcol2044_signed_tinyint_delete-within-range.test b/mtr/basic/t/mcol2044_signed_tinyint_delete-within-range.test new file mode 100644 index 000000000..a0e6b41fd --- /dev/null +++ b/mtr/basic/t/mcol2044_signed_tinyint_delete-within-range.test @@ -0,0 +1,11 @@ +# tests updates within range. +--disable_warnings +create database if not exists test_ranges; +use test_ranges; +drop table if exists t; +--enable_warnings +create table t(x tinyint) engine=columnstore; +insert into t(x) values (44),(55),(66); # range must be 44..66. +delete from t where x=55; # range must stay 44..66. +select max_value, min_value from information_schema.columnstore_extents; +drop database test_ranges; diff --git a/mtr/basic/t/mcol2044_signed_tinyint_insert-keeps-invalid-range.test b/mtr/basic/t/mcol2044_signed_tinyint_insert-keeps-invalid-range.test new file mode 100644 index 000000000..9e1d8ca1a --- /dev/null +++ b/mtr/basic/t/mcol2044_signed_tinyint_insert-keeps-invalid-range.test @@ -0,0 +1,12 @@ +# tests updates within range. +--disable_warnings +create database if not exists test_ranges; +use test_ranges; +drop table if exists t; +--enable_warnings +create table t(x tinyint) engine=columnstore; +insert into t(x) values (44),(55),(66); # range must be 44..66. +update t set x=65 where x=66; # range must drop to invalid +insert into t(x) values (77), (22); # range must stay invalid. +select max_value, min_value from information_schema.columnstore_extents; +drop database test_ranges; diff --git a/mtr/basic/t/mcol2044_signed_tinyint_update-drop-max.test b/mtr/basic/t/mcol2044_signed_tinyint_update-drop-max.test new file mode 100644 index 000000000..e15f80eb0 --- /dev/null +++ b/mtr/basic/t/mcol2044_signed_tinyint_update-drop-max.test @@ -0,0 +1,11 @@ +# tests updates that sets invalid range when we set value at max boundary that is less than max. +--disable_warnings +create database if not exists test_ranges; +use test_ranges; +drop table if exists t; +--enable_warnings +create table t(x tinyint) engine=columnstore; +insert into t(x) values (44),(55),(66); # range must be 44..66. +update t set x=65 where x=44; # range must drop to invalid +select max_value, min_value from information_schema.columnstore_extents; +drop database test_ranges; diff --git a/mtr/basic/t/mcol2044_signed_tinyint_update-drop-min.test b/mtr/basic/t/mcol2044_signed_tinyint_update-drop-min.test new file mode 100644 index 000000000..e9914f683 --- /dev/null +++ b/mtr/basic/t/mcol2044_signed_tinyint_update-drop-min.test @@ -0,0 +1,12 @@ +# tests updates that range when we updating min value to value that is bigger than min. +--disable_warnings +create database if not exists test_ranges; +use test_ranges; +drop table if exists t; +--enable_warnings +create table t(x tinyint) engine=columnstore; +insert into t(x) values (44),(55),(66); # range must be 44..66. +update t set x=65 where x=44; # range must be invalid now. + +select max_value, min_value from information_schema.columnstore_extents; +drop database test_ranges; diff --git a/mtr/basic/t/mcol2044_signed_tinyint_update-extends-max.test b/mtr/basic/t/mcol2044_signed_tinyint_update-extends-max.test new file mode 100644 index 000000000..f37d37332 --- /dev/null +++ b/mtr/basic/t/mcol2044_signed_tinyint_update-extends-max.test @@ -0,0 +1,11 @@ +# tests updates that extend max range, for values at max. +--disable_warnings +create database if not exists test_ranges; +use test_ranges; +drop table if exists t; +--enable_warnings +create table t(x tinyint) engine=columnstore; +insert into t(x) values (44),(55),(66); # range must be 44..66. +update t set x=77 where x=66; # range must be 44..77 +select max_value, min_value from information_schema.columnstore_extents; +drop database test_ranges; diff --git a/mtr/basic/t/mcol2044_signed_tinyint_update-extends-min.test b/mtr/basic/t/mcol2044_signed_tinyint_update-extends-min.test new file mode 100644 index 000000000..545f516db --- /dev/null +++ b/mtr/basic/t/mcol2044_signed_tinyint_update-extends-min.test @@ -0,0 +1,11 @@ +# tests updates that extend range to new min value. +--disable_warnings +create database if not exists test_ranges; +use test_ranges; +drop table if exists t; +--enable_warnings +create table t(x tinyint) engine=columnstore; +insert into t(x) values (44),(55),(66); # range must be 44..66. +update t set x=33 where x=44; # range must be 33..66. +select max_value, min_value from information_schema.columnstore_extents; +drop database test_ranges; diff --git a/mtr/basic/t/mcol2044_signed_tinyint_update-within-range.test b/mtr/basic/t/mcol2044_signed_tinyint_update-within-range.test new file mode 100644 index 000000000..182044d00 --- /dev/null +++ b/mtr/basic/t/mcol2044_signed_tinyint_update-within-range.test @@ -0,0 +1,11 @@ +# tests updates within range. +--disable_warnings +create database if not exists test_ranges; +use test_ranges; +drop table if exists t; +--enable_warnings +create table t(x tinyint) engine=columnstore; +insert into t(x) values (44),(55),(66); # range must be 44..66. +update t set x=65 where x=55; # range must stay 44..66. +select max_value, min_value from information_schema.columnstore_extents; +drop database test_ranges; diff --git a/mtr/basic/t/mcol2044_unsigned_bigint_delete-drop-max.test b/mtr/basic/t/mcol2044_unsigned_bigint_delete-drop-max.test new file mode 100644 index 000000000..7d7d47a57 --- /dev/null +++ b/mtr/basic/t/mcol2044_unsigned_bigint_delete-drop-max.test @@ -0,0 +1,13 @@ +# tests updates that sets invalid range when we set value at max boundary that is less than max. +--disable_warnings +create database if not exists test_ranges; +use test_ranges; +drop table if exists t; +--enable_warnings +create table t(x bigint unsigned) engine=columnstore; +insert into t(x) values (44),(55),(66); # range must be 44..66. +select max_value, min_value from information_schema.columnstore_extents; +delete from t where x=44; # range must drop to invalid +select max_value, min_value from information_schema.columnstore_extents; + +drop database test_ranges; diff --git a/mtr/basic/t/mcol2044_unsigned_bigint_delete-drop-min.test b/mtr/basic/t/mcol2044_unsigned_bigint_delete-drop-min.test new file mode 100644 index 000000000..50ed3410d --- /dev/null +++ b/mtr/basic/t/mcol2044_unsigned_bigint_delete-drop-min.test @@ -0,0 +1,12 @@ +# tests updates that range when we updating min value to value that is bigger than min. +--disable_warnings +create database if not exists test_ranges; +use test_ranges; +drop table if exists t; +--enable_warnings +create table t(x bigint unsigned) engine=columnstore; +insert into t(x) values (44),(55),(66); # range must be 44..66. +select max_value, min_value from information_schema.columnstore_extents; +delete from t where x=66; # range must be invalid now. +select max_value, min_value from information_schema.columnstore_extents; +drop database test_ranges; diff --git a/mtr/basic/t/mcol2044_unsigned_bigint_delete-within-range.test b/mtr/basic/t/mcol2044_unsigned_bigint_delete-within-range.test new file mode 100644 index 000000000..0fc402aad --- /dev/null +++ b/mtr/basic/t/mcol2044_unsigned_bigint_delete-within-range.test @@ -0,0 +1,11 @@ +# tests updates within range. +--disable_warnings +create database if not exists test_ranges; +use test_ranges; +drop table if exists t; +--enable_warnings +create table t(x bigint unsigned) engine=columnstore; +insert into t(x) values (44),(55),(66); # range must be 44..66. +delete from t where x=55; # range must stay 44..66. +select max_value, min_value from information_schema.columnstore_extents; +drop database test_ranges; diff --git a/mtr/basic/t/mcol2044_unsigned_bigint_insert-keeps-invalid-range.test b/mtr/basic/t/mcol2044_unsigned_bigint_insert-keeps-invalid-range.test new file mode 100644 index 000000000..b1fb9b543 --- /dev/null +++ b/mtr/basic/t/mcol2044_unsigned_bigint_insert-keeps-invalid-range.test @@ -0,0 +1,12 @@ +# tests updates within range. +--disable_warnings +create database if not exists test_ranges; +use test_ranges; +drop table if exists t; +--enable_warnings +create table t(x bigint unsigned) engine=columnstore; +insert into t(x) values (44),(55),(66); # range must be 44..66. +update t set x=65 where x=66; # range must drop to invalid +insert into t(x) values (77), (22); # range must stay invalid. +select max_value, min_value from information_schema.columnstore_extents; +drop database test_ranges; diff --git a/mtr/basic/t/mcol2044_unsigned_bigint_update-drop-max.test b/mtr/basic/t/mcol2044_unsigned_bigint_update-drop-max.test new file mode 100644 index 000000000..db4ce5d75 --- /dev/null +++ b/mtr/basic/t/mcol2044_unsigned_bigint_update-drop-max.test @@ -0,0 +1,11 @@ +# tests updates that sets invalid range when we set value at max boundary that is less than max. +--disable_warnings +create database if not exists test_ranges; +use test_ranges; +drop table if exists t; +--enable_warnings +create table t(x bigint unsigned) engine=columnstore; +insert into t(x) values (44),(55),(66); # range must be 44..66. +update t set x=65 where x=44; # range must drop to invalid +select max_value, min_value from information_schema.columnstore_extents; +drop database test_ranges; diff --git a/mtr/basic/t/mcol2044_unsigned_bigint_update-drop-min.test b/mtr/basic/t/mcol2044_unsigned_bigint_update-drop-min.test new file mode 100644 index 000000000..da891ede3 --- /dev/null +++ b/mtr/basic/t/mcol2044_unsigned_bigint_update-drop-min.test @@ -0,0 +1,12 @@ +# tests updates that range when we updating min value to value that is bigger than min. +--disable_warnings +create database if not exists test_ranges; +use test_ranges; +drop table if exists t; +--enable_warnings +create table t(x bigint unsigned) engine=columnstore; +insert into t(x) values (44),(55),(66); # range must be 44..66. +update t set x=65 where x=44; # range must be invalid now. + +select max_value, min_value from information_schema.columnstore_extents; +drop database test_ranges; diff --git a/mtr/basic/t/mcol2044_unsigned_bigint_update-extends-max.test b/mtr/basic/t/mcol2044_unsigned_bigint_update-extends-max.test new file mode 100644 index 000000000..c940841c1 --- /dev/null +++ b/mtr/basic/t/mcol2044_unsigned_bigint_update-extends-max.test @@ -0,0 +1,11 @@ +# tests updates that extend max range, for values at max. +--disable_warnings +create database if not exists test_ranges; +use test_ranges; +drop table if exists t; +--enable_warnings +create table t(x bigint unsigned) engine=columnstore; +insert into t(x) values (44),(55),(66); # range must be 44..66. +update t set x=77 where x=66; # range must be 44..77 +select max_value, min_value from information_schema.columnstore_extents; +drop database test_ranges; diff --git a/mtr/basic/t/mcol2044_unsigned_bigint_update-extends-min.test b/mtr/basic/t/mcol2044_unsigned_bigint_update-extends-min.test new file mode 100644 index 000000000..271ec6350 --- /dev/null +++ b/mtr/basic/t/mcol2044_unsigned_bigint_update-extends-min.test @@ -0,0 +1,11 @@ +# tests updates that extend range to new min value. +--disable_warnings +create database if not exists test_ranges; +use test_ranges; +drop table if exists t; +--enable_warnings +create table t(x bigint unsigned) engine=columnstore; +insert into t(x) values (44),(55),(66); # range must be 44..66. +update t set x=33 where x=44; # range must be 33..66. +select max_value, min_value from information_schema.columnstore_extents; +drop database test_ranges; diff --git a/mtr/basic/t/mcol2044_unsigned_bigint_update-within-range.test b/mtr/basic/t/mcol2044_unsigned_bigint_update-within-range.test new file mode 100644 index 000000000..9ab0b325f --- /dev/null +++ b/mtr/basic/t/mcol2044_unsigned_bigint_update-within-range.test @@ -0,0 +1,11 @@ +# tests updates within range. +--disable_warnings +create database if not exists test_ranges; +use test_ranges; +drop table if exists t; +--enable_warnings +create table t(x bigint unsigned) engine=columnstore; +insert into t(x) values (44),(55),(66); # range must be 44..66. +update t set x=65 where x=55; # range must stay 44..66. +select max_value, min_value from information_schema.columnstore_extents; +drop database test_ranges; diff --git a/mtr/basic/t/mcol2044_unsigned_dec38_delete-drop-max.test b/mtr/basic/t/mcol2044_unsigned_dec38_delete-drop-max.test new file mode 100644 index 000000000..7d7d47a57 --- /dev/null +++ b/mtr/basic/t/mcol2044_unsigned_dec38_delete-drop-max.test @@ -0,0 +1,13 @@ +# tests updates that sets invalid range when we set value at max boundary that is less than max. +--disable_warnings +create database if not exists test_ranges; +use test_ranges; +drop table if exists t; +--enable_warnings +create table t(x bigint unsigned) engine=columnstore; +insert into t(x) values (44),(55),(66); # range must be 44..66. +select max_value, min_value from information_schema.columnstore_extents; +delete from t where x=44; # range must drop to invalid +select max_value, min_value from information_schema.columnstore_extents; + +drop database test_ranges; diff --git a/mtr/basic/t/mcol2044_unsigned_dec38_delete-drop-min.test b/mtr/basic/t/mcol2044_unsigned_dec38_delete-drop-min.test new file mode 100644 index 000000000..50ed3410d --- /dev/null +++ b/mtr/basic/t/mcol2044_unsigned_dec38_delete-drop-min.test @@ -0,0 +1,12 @@ +# tests updates that range when we updating min value to value that is bigger than min. +--disable_warnings +create database if not exists test_ranges; +use test_ranges; +drop table if exists t; +--enable_warnings +create table t(x bigint unsigned) engine=columnstore; +insert into t(x) values (44),(55),(66); # range must be 44..66. +select max_value, min_value from information_schema.columnstore_extents; +delete from t where x=66; # range must be invalid now. +select max_value, min_value from information_schema.columnstore_extents; +drop database test_ranges; diff --git a/mtr/basic/t/mcol2044_unsigned_dec38_delete-within-range.test b/mtr/basic/t/mcol2044_unsigned_dec38_delete-within-range.test new file mode 100644 index 000000000..0fc402aad --- /dev/null +++ b/mtr/basic/t/mcol2044_unsigned_dec38_delete-within-range.test @@ -0,0 +1,11 @@ +# tests updates within range. +--disable_warnings +create database if not exists test_ranges; +use test_ranges; +drop table if exists t; +--enable_warnings +create table t(x bigint unsigned) engine=columnstore; +insert into t(x) values (44),(55),(66); # range must be 44..66. +delete from t where x=55; # range must stay 44..66. +select max_value, min_value from information_schema.columnstore_extents; +drop database test_ranges; diff --git a/mtr/basic/t/mcol2044_unsigned_dec38_insert-keeps-invalid-range.test b/mtr/basic/t/mcol2044_unsigned_dec38_insert-keeps-invalid-range.test new file mode 100644 index 000000000..b1fb9b543 --- /dev/null +++ b/mtr/basic/t/mcol2044_unsigned_dec38_insert-keeps-invalid-range.test @@ -0,0 +1,12 @@ +# tests updates within range. +--disable_warnings +create database if not exists test_ranges; +use test_ranges; +drop table if exists t; +--enable_warnings +create table t(x bigint unsigned) engine=columnstore; +insert into t(x) values (44),(55),(66); # range must be 44..66. +update t set x=65 where x=66; # range must drop to invalid +insert into t(x) values (77), (22); # range must stay invalid. +select max_value, min_value from information_schema.columnstore_extents; +drop database test_ranges; diff --git a/mtr/basic/t/mcol2044_unsigned_dec38_update-drop-max.test b/mtr/basic/t/mcol2044_unsigned_dec38_update-drop-max.test new file mode 100644 index 000000000..db4ce5d75 --- /dev/null +++ b/mtr/basic/t/mcol2044_unsigned_dec38_update-drop-max.test @@ -0,0 +1,11 @@ +# tests updates that sets invalid range when we set value at max boundary that is less than max. +--disable_warnings +create database if not exists test_ranges; +use test_ranges; +drop table if exists t; +--enable_warnings +create table t(x bigint unsigned) engine=columnstore; +insert into t(x) values (44),(55),(66); # range must be 44..66. +update t set x=65 where x=44; # range must drop to invalid +select max_value, min_value from information_schema.columnstore_extents; +drop database test_ranges; diff --git a/mtr/basic/t/mcol2044_unsigned_dec38_update-drop-min.test b/mtr/basic/t/mcol2044_unsigned_dec38_update-drop-min.test new file mode 100644 index 000000000..da891ede3 --- /dev/null +++ b/mtr/basic/t/mcol2044_unsigned_dec38_update-drop-min.test @@ -0,0 +1,12 @@ +# tests updates that range when we updating min value to value that is bigger than min. +--disable_warnings +create database if not exists test_ranges; +use test_ranges; +drop table if exists t; +--enable_warnings +create table t(x bigint unsigned) engine=columnstore; +insert into t(x) values (44),(55),(66); # range must be 44..66. +update t set x=65 where x=44; # range must be invalid now. + +select max_value, min_value from information_schema.columnstore_extents; +drop database test_ranges; diff --git a/mtr/basic/t/mcol2044_unsigned_dec38_update-extends-max.test b/mtr/basic/t/mcol2044_unsigned_dec38_update-extends-max.test new file mode 100644 index 000000000..c940841c1 --- /dev/null +++ b/mtr/basic/t/mcol2044_unsigned_dec38_update-extends-max.test @@ -0,0 +1,11 @@ +# tests updates that extend max range, for values at max. +--disable_warnings +create database if not exists test_ranges; +use test_ranges; +drop table if exists t; +--enable_warnings +create table t(x bigint unsigned) engine=columnstore; +insert into t(x) values (44),(55),(66); # range must be 44..66. +update t set x=77 where x=66; # range must be 44..77 +select max_value, min_value from information_schema.columnstore_extents; +drop database test_ranges; diff --git a/mtr/basic/t/mcol2044_unsigned_dec38_update-extends-min.test b/mtr/basic/t/mcol2044_unsigned_dec38_update-extends-min.test new file mode 100644 index 000000000..271ec6350 --- /dev/null +++ b/mtr/basic/t/mcol2044_unsigned_dec38_update-extends-min.test @@ -0,0 +1,11 @@ +# tests updates that extend range to new min value. +--disable_warnings +create database if not exists test_ranges; +use test_ranges; +drop table if exists t; +--enable_warnings +create table t(x bigint unsigned) engine=columnstore; +insert into t(x) values (44),(55),(66); # range must be 44..66. +update t set x=33 where x=44; # range must be 33..66. +select max_value, min_value from information_schema.columnstore_extents; +drop database test_ranges; diff --git a/mtr/basic/t/mcol2044_unsigned_dec38_update-within-range.test b/mtr/basic/t/mcol2044_unsigned_dec38_update-within-range.test new file mode 100644 index 000000000..9ab0b325f --- /dev/null +++ b/mtr/basic/t/mcol2044_unsigned_dec38_update-within-range.test @@ -0,0 +1,11 @@ +# tests updates within range. +--disable_warnings +create database if not exists test_ranges; +use test_ranges; +drop table if exists t; +--enable_warnings +create table t(x bigint unsigned) engine=columnstore; +insert into t(x) values (44),(55),(66); # range must be 44..66. +update t set x=65 where x=55; # range must stay 44..66. +select max_value, min_value from information_schema.columnstore_extents; +drop database test_ranges; diff --git a/mtr/basic/t/mcol2044_unsigned_integer_delete-drop-max.test b/mtr/basic/t/mcol2044_unsigned_integer_delete-drop-max.test new file mode 100644 index 000000000..7e7fd2bc4 --- /dev/null +++ b/mtr/basic/t/mcol2044_unsigned_integer_delete-drop-max.test @@ -0,0 +1,13 @@ +# tests updates that sets invalid range when we set value at max boundary that is less than max. +--disable_warnings +create database if not exists test_ranges; +use test_ranges; +drop table if exists t; +--enable_warnings +create table t(x integer unsigned) engine=columnstore; +insert into t(x) values (44),(55),(66); # range must be 44..66. +select max_value, min_value from information_schema.columnstore_extents; +delete from t where x=44; # range must drop to invalid +select max_value, min_value from information_schema.columnstore_extents; + +drop database test_ranges; diff --git a/mtr/basic/t/mcol2044_unsigned_integer_delete-drop-min.test b/mtr/basic/t/mcol2044_unsigned_integer_delete-drop-min.test new file mode 100644 index 000000000..7f05c3ee7 --- /dev/null +++ b/mtr/basic/t/mcol2044_unsigned_integer_delete-drop-min.test @@ -0,0 +1,12 @@ +# tests updates that range when we updating min value to value that is bigger than min. +--disable_warnings +create database if not exists test_ranges; +use test_ranges; +drop table if exists t; +--enable_warnings +create table t(x integer unsigned) engine=columnstore; +insert into t(x) values (44),(55),(66); # range must be 44..66. +select max_value, min_value from information_schema.columnstore_extents; +delete from t where x=66; # range must be invalid now. +select max_value, min_value from information_schema.columnstore_extents; +drop database test_ranges; diff --git a/mtr/basic/t/mcol2044_unsigned_integer_delete-within-range.test b/mtr/basic/t/mcol2044_unsigned_integer_delete-within-range.test new file mode 100644 index 000000000..764c2a173 --- /dev/null +++ b/mtr/basic/t/mcol2044_unsigned_integer_delete-within-range.test @@ -0,0 +1,11 @@ +# tests updates within range. +--disable_warnings +create database if not exists test_ranges; +use test_ranges; +drop table if exists t; +--enable_warnings +create table t(x integer unsigned) engine=columnstore; +insert into t(x) values (44),(55),(66); # range must be 44..66. +delete from t where x=55; # range must stay 44..66. +select max_value, min_value from information_schema.columnstore_extents; +drop database test_ranges; diff --git a/mtr/basic/t/mcol2044_unsigned_integer_insert-keeps-invalid-range.test b/mtr/basic/t/mcol2044_unsigned_integer_insert-keeps-invalid-range.test new file mode 100644 index 000000000..24fe935bb --- /dev/null +++ b/mtr/basic/t/mcol2044_unsigned_integer_insert-keeps-invalid-range.test @@ -0,0 +1,12 @@ +# tests updates within range. +--disable_warnings +create database if not exists test_ranges; +use test_ranges; +drop table if exists t; +--enable_warnings +create table t(x integer unsigned) engine=columnstore; +insert into t(x) values (44),(55),(66); # range must be 44..66. +update t set x=65 where x=66; # range must drop to invalid +insert into t(x) values (77), (22); # range must stay invalid. +select max_value, min_value from information_schema.columnstore_extents; +drop database test_ranges; diff --git a/mtr/basic/t/mcol2044_unsigned_integer_update-drop-max.test b/mtr/basic/t/mcol2044_unsigned_integer_update-drop-max.test new file mode 100644 index 000000000..29ec67efa --- /dev/null +++ b/mtr/basic/t/mcol2044_unsigned_integer_update-drop-max.test @@ -0,0 +1,11 @@ +# tests updates that sets invalid range when we set value at max boundary that is less than max. +--disable_warnings +create database if not exists test_ranges; +use test_ranges; +drop table if exists t; +--enable_warnings +create table t(x integer unsigned) engine=columnstore; +insert into t(x) values (44),(55),(66); # range must be 44..66. +update t set x=65 where x=44; # range must drop to invalid +select max_value, min_value from information_schema.columnstore_extents; +drop database test_ranges; diff --git a/mtr/basic/t/mcol2044_unsigned_integer_update-drop-min.test b/mtr/basic/t/mcol2044_unsigned_integer_update-drop-min.test new file mode 100644 index 000000000..d19f0f65c --- /dev/null +++ b/mtr/basic/t/mcol2044_unsigned_integer_update-drop-min.test @@ -0,0 +1,12 @@ +# tests updates that range when we updating min value to value that is bigger than min. +--disable_warnings +create database if not exists test_ranges; +use test_ranges; +drop table if exists t; +--enable_warnings +create table t(x integer unsigned) engine=columnstore; +insert into t(x) values (44),(55),(66); # range must be 44..66. +update t set x=65 where x=44; # range must be invalid now. + +select max_value, min_value from information_schema.columnstore_extents; +drop database test_ranges; diff --git a/mtr/basic/t/mcol2044_unsigned_integer_update-extends-max.test b/mtr/basic/t/mcol2044_unsigned_integer_update-extends-max.test new file mode 100644 index 000000000..cb3cec319 --- /dev/null +++ b/mtr/basic/t/mcol2044_unsigned_integer_update-extends-max.test @@ -0,0 +1,11 @@ +# tests updates that extend max range, for values at max. +--disable_warnings +create database if not exists test_ranges; +use test_ranges; +drop table if exists t; +--enable_warnings +create table t(x integer unsigned) engine=columnstore; +insert into t(x) values (44),(55),(66); # range must be 44..66. +update t set x=77 where x=66; # range must be 44..77 +select max_value, min_value from information_schema.columnstore_extents; +drop database test_ranges; diff --git a/mtr/basic/t/mcol2044_unsigned_integer_update-extends-min.test b/mtr/basic/t/mcol2044_unsigned_integer_update-extends-min.test new file mode 100644 index 000000000..965f555fb --- /dev/null +++ b/mtr/basic/t/mcol2044_unsigned_integer_update-extends-min.test @@ -0,0 +1,11 @@ +# tests updates that extend range to new min value. +--disable_warnings +create database if not exists test_ranges; +use test_ranges; +drop table if exists t; +--enable_warnings +create table t(x integer unsigned) engine=columnstore; +insert into t(x) values (44),(55),(66); # range must be 44..66. +update t set x=33 where x=44; # range must be 33..66. +select max_value, min_value from information_schema.columnstore_extents; +drop database test_ranges; diff --git a/mtr/basic/t/mcol2044_unsigned_integer_update-within-range.test b/mtr/basic/t/mcol2044_unsigned_integer_update-within-range.test new file mode 100644 index 000000000..0b8e6f460 --- /dev/null +++ b/mtr/basic/t/mcol2044_unsigned_integer_update-within-range.test @@ -0,0 +1,11 @@ +# tests updates within range. +--disable_warnings +create database if not exists test_ranges; +use test_ranges; +drop table if exists t; +--enable_warnings +create table t(x integer unsigned) engine=columnstore; +insert into t(x) values (44),(55),(66); # range must be 44..66. +update t set x=65 where x=55; # range must stay 44..66. +select max_value, min_value from information_schema.columnstore_extents; +drop database test_ranges; diff --git a/mtr/basic/t/mcol2044_unsigned_smallint_delete-drop-max.test b/mtr/basic/t/mcol2044_unsigned_smallint_delete-drop-max.test new file mode 100644 index 000000000..73a5b9961 --- /dev/null +++ b/mtr/basic/t/mcol2044_unsigned_smallint_delete-drop-max.test @@ -0,0 +1,12 @@ +# tests updates that sets invalid range when we set value at max boundary that is less than max. +--disable_warnings +create database if not exists test_ranges; +use test_ranges; +drop table if exists t; +--enable_warnings +create table t(x smallint unsigned) engine=columnstore; +insert into t(x) values (44),(55),(66); # range must be 44..66. +select max_value, min_value from information_schema.columnstore_extents; +delete from t where x=44; # range must drop to invalid +select max_value, min_value from information_schema.columnstore_extents; +drop database test_ranges; diff --git a/mtr/basic/t/mcol2044_unsigned_smallint_delete-drop-min.test b/mtr/basic/t/mcol2044_unsigned_smallint_delete-drop-min.test new file mode 100644 index 000000000..8155556d4 --- /dev/null +++ b/mtr/basic/t/mcol2044_unsigned_smallint_delete-drop-min.test @@ -0,0 +1,12 @@ +# tests updates that range when we updating min value to value that is bigger than min. +--disable_warnings +create database if not exists test_ranges; +use test_ranges; +drop table if exists t; +--enable_warnings +create table t(x smallint unsigned) engine=columnstore; +insert into t(x) values (44),(55),(66); # range must be 44..66. +select max_value, min_value from information_schema.columnstore_extents; +delete from t where x=66; # range must be invalid now. +select max_value, min_value from information_schema.columnstore_extents; +drop database test_ranges; diff --git a/mtr/basic/t/mcol2044_unsigned_smallint_delete-within-range.test b/mtr/basic/t/mcol2044_unsigned_smallint_delete-within-range.test new file mode 100644 index 000000000..4e2470eab --- /dev/null +++ b/mtr/basic/t/mcol2044_unsigned_smallint_delete-within-range.test @@ -0,0 +1,11 @@ +# tests updates within range. +--disable_warnings +create database if not exists test_ranges; +use test_ranges; +drop table if exists t; +--enable_warnings +create table t(x smallint unsigned) engine=columnstore; +insert into t(x) values (44),(55),(66); # range must be 44..66. +delete from t where x=55; # range must stay 44..66. +select max_value, min_value from information_schema.columnstore_extents; +drop database test_ranges; diff --git a/mtr/basic/t/mcol2044_unsigned_smallint_insert-keeps-invalid-range.test b/mtr/basic/t/mcol2044_unsigned_smallint_insert-keeps-invalid-range.test new file mode 100644 index 000000000..f5b329741 --- /dev/null +++ b/mtr/basic/t/mcol2044_unsigned_smallint_insert-keeps-invalid-range.test @@ -0,0 +1,12 @@ +# tests updates within range. +--disable_warnings +create database if not exists test_ranges; +use test_ranges; +drop table if exists t; +--enable_warnings +create table t(x smallint unsigned) engine=columnstore; +insert into t(x) values (44),(55),(66); # range must be 44..66. +update t set x=65 where x=66; # range must drop to invalid +insert into t(x) values (77), (22); # range must stay invalid. +select max_value, min_value from information_schema.columnstore_extents; +drop database test_ranges; diff --git a/mtr/basic/t/mcol2044_unsigned_smallint_update-drop-max.test b/mtr/basic/t/mcol2044_unsigned_smallint_update-drop-max.test new file mode 100644 index 000000000..e49e0c960 --- /dev/null +++ b/mtr/basic/t/mcol2044_unsigned_smallint_update-drop-max.test @@ -0,0 +1,11 @@ +# tests updates that sets invalid range when we set value at max boundary that is less than max. +--disable_warnings +create database if not exists test_ranges; +use test_ranges; +drop table if exists t; +--enable_warnings +create table t(x smallint unsigned) engine=columnstore; +insert into t(x) values (44),(55),(66); # range must be 44..66. +update t set x=65 where x=44; # range must drop to invalid +select max_value, min_value from information_schema.columnstore_extents; +drop database test_ranges; diff --git a/mtr/basic/t/mcol2044_unsigned_smallint_update-drop-min.test b/mtr/basic/t/mcol2044_unsigned_smallint_update-drop-min.test new file mode 100644 index 000000000..9a302e527 --- /dev/null +++ b/mtr/basic/t/mcol2044_unsigned_smallint_update-drop-min.test @@ -0,0 +1,12 @@ +# tests updates that range when we updating min value to value that is bigger than min. +--disable_warnings +create database if not exists test_ranges; +use test_ranges; +drop table if exists t; +--enable_warnings +create table t(x smallint unsigned) engine=columnstore; +insert into t(x) values (44),(55),(66); # range must be 44..66. +update t set x=65 where x=44; # range must be invalid now. + +select max_value, min_value from information_schema.columnstore_extents; +drop database test_ranges; diff --git a/mtr/basic/t/mcol2044_unsigned_smallint_update-extends-max.test b/mtr/basic/t/mcol2044_unsigned_smallint_update-extends-max.test new file mode 100644 index 000000000..e9960b236 --- /dev/null +++ b/mtr/basic/t/mcol2044_unsigned_smallint_update-extends-max.test @@ -0,0 +1,11 @@ +# tests updates that extend max range, for values at max. +--disable_warnings +create database if not exists test_ranges; +use test_ranges; +drop table if exists t; +--enable_warnings +create table t(x smallint unsigned) engine=columnstore; +insert into t(x) values (44),(55),(66); # range must be 44..66. +update t set x=77 where x=66; # range must be 44..77 +select max_value, min_value from information_schema.columnstore_extents; +drop database test_ranges; diff --git a/mtr/basic/t/mcol2044_unsigned_smallint_update-extends-min.test b/mtr/basic/t/mcol2044_unsigned_smallint_update-extends-min.test new file mode 100644 index 000000000..a4c6ff381 --- /dev/null +++ b/mtr/basic/t/mcol2044_unsigned_smallint_update-extends-min.test @@ -0,0 +1,11 @@ +# tests updates that extend range to new min value. +--disable_warnings +create database if not exists test_ranges; +use test_ranges; +drop table if exists t; +--enable_warnings +create table t(x smallint unsigned) engine=columnstore; +insert into t(x) values (44),(55),(66); # range must be 44..66. +update t set x=33 where x=44; # range must be 33..66. +select max_value, min_value from information_schema.columnstore_extents; +drop database test_ranges; diff --git a/mtr/basic/t/mcol2044_unsigned_smallint_update-within-range.test b/mtr/basic/t/mcol2044_unsigned_smallint_update-within-range.test new file mode 100644 index 000000000..02a6b3e64 --- /dev/null +++ b/mtr/basic/t/mcol2044_unsigned_smallint_update-within-range.test @@ -0,0 +1,11 @@ +# tests updates within range. +--disable_warnings +create database if not exists test_ranges; +use test_ranges; +drop table if exists t; +--enable_warnings +create table t(x smallint unsigned) engine=columnstore; +insert into t(x) values (44),(55),(66); # range must be 44..66. +update t set x=65 where x=55; # range must stay 44..66. +select max_value, min_value from information_schema.columnstore_extents; +drop database test_ranges; diff --git a/mtr/basic/t/mcol2044_unsigned_tinyint_delete-drop-max.test b/mtr/basic/t/mcol2044_unsigned_tinyint_delete-drop-max.test new file mode 100644 index 000000000..25fa16468 --- /dev/null +++ b/mtr/basic/t/mcol2044_unsigned_tinyint_delete-drop-max.test @@ -0,0 +1,12 @@ +# tests updates that sets invalid range when we set value at max boundary that is less than max. +--disable_warnings +create database if not exists test_ranges; +use test_ranges; +drop table if exists t; +--enable_warnings +create table t(x tinyint unsigned) engine=columnstore; +insert into t(x) values (44),(55),(66); # range must be 44..66. +select max_value, min_value from information_schema.columnstore_extents; +delete from t where x=44; # range must drop to invalid +select max_value, min_value from information_schema.columnstore_extents; +drop database test_ranges; diff --git a/mtr/basic/t/mcol2044_unsigned_tinyint_delete-drop-min.test b/mtr/basic/t/mcol2044_unsigned_tinyint_delete-drop-min.test new file mode 100644 index 000000000..4fdb71c13 --- /dev/null +++ b/mtr/basic/t/mcol2044_unsigned_tinyint_delete-drop-min.test @@ -0,0 +1,12 @@ +# tests updates that range when we updating min value to value that is bigger than min. +--disable_warnings +create database if not exists test_ranges; +use test_ranges; +drop table if exists t; +--enable_warnings +create table t(x tinyint unsigned) engine=columnstore; +insert into t(x) values (44),(55),(66); # range must be 44..66. +select max_value, min_value from information_schema.columnstore_extents; +delete from t where x=66; # range must be invalid now. +select max_value, min_value from information_schema.columnstore_extents; +drop database test_ranges; diff --git a/mtr/basic/t/mcol2044_unsigned_tinyint_delete-within-range.test b/mtr/basic/t/mcol2044_unsigned_tinyint_delete-within-range.test new file mode 100644 index 000000000..a9e9e53da --- /dev/null +++ b/mtr/basic/t/mcol2044_unsigned_tinyint_delete-within-range.test @@ -0,0 +1,11 @@ +# tests updates within range. +--disable_warnings +create database if not exists test_ranges; +use test_ranges; +drop table if exists t; +--enable_warnings +create table t(x tinyint unsigned) engine=columnstore; +insert into t(x) values (44),(55),(66); # range must be 44..66. +delete from t where x=55; # range must stay 44..66. +select max_value, min_value from information_schema.columnstore_extents; +drop database test_ranges; diff --git a/mtr/basic/t/mcol2044_unsigned_tinyint_insert-keeps-invalid-range.test b/mtr/basic/t/mcol2044_unsigned_tinyint_insert-keeps-invalid-range.test new file mode 100644 index 000000000..f4634e636 --- /dev/null +++ b/mtr/basic/t/mcol2044_unsigned_tinyint_insert-keeps-invalid-range.test @@ -0,0 +1,12 @@ +# tests updates within range. +--disable_warnings +create database if not exists test_ranges; +use test_ranges; +drop table if exists t; +--enable_warnings +create table t(x tinyint unsigned) engine=columnstore; +insert into t(x) values (44),(55),(66); # range must be 44..66. +update t set x=65 where x=66; # range must drop to invalid +insert into t(x) values (77), (22); # range must stay invalid. +select max_value, min_value from information_schema.columnstore_extents; +drop database test_ranges; diff --git a/mtr/basic/t/mcol2044_unsigned_tinyint_update-drop-max.test b/mtr/basic/t/mcol2044_unsigned_tinyint_update-drop-max.test new file mode 100644 index 000000000..31dce6d05 --- /dev/null +++ b/mtr/basic/t/mcol2044_unsigned_tinyint_update-drop-max.test @@ -0,0 +1,11 @@ +# tests updates that sets invalid range when we set value at max boundary that is less than max. +--disable_warnings +create database if not exists test_ranges; +use test_ranges; +drop table if exists t; +--enable_warnings +create table t(x tinyint unsigned) engine=columnstore; +insert into t(x) values (44),(55),(66); # range must be 44..66. +update t set x=65 where x=44; # range must drop to invalid +select max_value, min_value from information_schema.columnstore_extents; +drop database test_ranges; diff --git a/mtr/basic/t/mcol2044_unsigned_tinyint_update-drop-min.test b/mtr/basic/t/mcol2044_unsigned_tinyint_update-drop-min.test new file mode 100644 index 000000000..10db862e4 --- /dev/null +++ b/mtr/basic/t/mcol2044_unsigned_tinyint_update-drop-min.test @@ -0,0 +1,12 @@ +# tests updates that range when we updating min value to value that is bigger than min. +--disable_warnings +create database if not exists test_ranges; +use test_ranges; +drop table if exists t; +--enable_warnings +create table t(x tinyint unsigned) engine=columnstore; +insert into t(x) values (44),(55),(66); # range must be 44..66. +update t set x=65 where x=44; # range must be invalid now. + +select max_value, min_value from information_schema.columnstore_extents; +drop database test_ranges; diff --git a/mtr/basic/t/mcol2044_unsigned_tinyint_update-extends-max.test b/mtr/basic/t/mcol2044_unsigned_tinyint_update-extends-max.test new file mode 100644 index 000000000..193139cef --- /dev/null +++ b/mtr/basic/t/mcol2044_unsigned_tinyint_update-extends-max.test @@ -0,0 +1,11 @@ +# tests updates that extend max range, for values at max. +--disable_warnings +create database if not exists test_ranges; +use test_ranges; +drop table if exists t; +--enable_warnings +create table t(x tinyint unsigned) engine=columnstore; +insert into t(x) values (44),(55),(66); # range must be 44..66. +update t set x=77 where x=66; # range must be 44..77 +select max_value, min_value from information_schema.columnstore_extents; +drop database test_ranges; diff --git a/mtr/basic/t/mcol2044_unsigned_tinyint_update-extends-min.test b/mtr/basic/t/mcol2044_unsigned_tinyint_update-extends-min.test new file mode 100644 index 000000000..5e991967c --- /dev/null +++ b/mtr/basic/t/mcol2044_unsigned_tinyint_update-extends-min.test @@ -0,0 +1,11 @@ +# tests updates that extend range to new min value. +--disable_warnings +create database if not exists test_ranges; +use test_ranges; +drop table if exists t; +--enable_warnings +create table t(x tinyint unsigned) engine=columnstore; +insert into t(x) values (44),(55),(66); # range must be 44..66. +update t set x=33 where x=44; # range must be 33..66. +select max_value, min_value from information_schema.columnstore_extents; +drop database test_ranges; diff --git a/mtr/basic/t/mcol2044_unsigned_tinyint_update-within-range.test b/mtr/basic/t/mcol2044_unsigned_tinyint_update-within-range.test new file mode 100644 index 000000000..bf738fa7f --- /dev/null +++ b/mtr/basic/t/mcol2044_unsigned_tinyint_update-within-range.test @@ -0,0 +1,11 @@ +# tests updates within range. +--disable_warnings +create database if not exists test_ranges; +use test_ranges; +drop table if exists t; +--enable_warnings +create table t(x tinyint unsigned) engine=columnstore; +insert into t(x) values (44),(55),(66); # range must be 44..66. +update t set x=65 where x=55; # range must stay 44..66. +select max_value, min_value from information_schema.columnstore_extents; +drop database test_ranges; diff --git a/versioning/BRM/brmtypes.h b/versioning/BRM/brmtypes.h index 623720263..871d7dee9 100644 --- a/versioning/BRM/brmtypes.h +++ b/versioning/BRM/brmtypes.h @@ -145,6 +145,10 @@ typedef struct _SIDTIDEntry SIDTIDEntry; // @bug 1970 - Added CPInfo and CPMaxMin structs used by new interface that allows setting the max and min CP data // for multiple extents. +// Special seqNum field values. +#define SEQNUM_MARK_INVALID (-1) +#define SEQNUM_MARK_INVALID_SET_RANGE (-2) + // Used in vectors. struct CPInfo { @@ -162,7 +166,7 @@ struct CPInfo int128_t bigMin; int64_t min_; }; - bool isBinaryColumn; + bool isBinaryColumn; // XXX: we should remove these two fields and replace it with type handler. }; typedef std::vector CPInfoList_t; @@ -182,7 +186,8 @@ struct CPMaxMin int128_t bigMin; int64_t min_; }; - bool isBinaryColumn; + bool isBinaryColumn; // XXX: these two fields should be replaced with type handler pointer. + }; typedef std::tr1::unordered_map CPMaxMinMap_t; diff --git a/versioning/BRM/dbrm.cpp b/versioning/BRM/dbrm.cpp index 7c8b3c860..4aa222bc1 100644 --- a/versioning/BRM/dbrm.cpp +++ b/versioning/BRM/dbrm.cpp @@ -491,6 +491,21 @@ int DBRM::getExtentMaxMin(const LBID_t lbid, T& max, T& min, int32_t& seqNum) th } } +int DBRM::getExtentCPMaxMin(const LBID_t lbid, CPMaxMin& cpMaxMin) throw() +{ + try + { + em->getCPMaxMin(lbid, cpMaxMin); + } + catch (...) + { + return ERR_FAILURE; + } + return ERR_OK; +} + + + int DBRM::setExtentMaxMin(const LBID_t lbid, const int64_t max, const int64_t min, const int32_t seqNum) DBRM_THROW { #ifdef BRM_INFO @@ -4574,7 +4589,7 @@ void DBRM::invalidateUncommittedExtentLBIDs(execplan::CalpontSystemCatalog::SCN aInfo.isBinaryColumn = false; } - aInfo.seqNum = -2; + aInfo.seqNum = SEQNUM_MARK_INVALID_SET_RANGE; cpInfos.push_back(aInfo); } diff --git a/versioning/BRM/dbrm.h b/versioning/BRM/dbrm.h index 90b24d203..7da9ca0fa 100644 --- a/versioning/BRM/dbrm.h +++ b/versioning/BRM/dbrm.h @@ -827,6 +827,8 @@ public: EXPORT int setExtentMaxMin(const LBID_t lbid, const int64_t max, const int64_t min, const int32_t seqNum) DBRM_THROW; + EXPORT int getExtentCPMaxMin(const LBID_t lbid, CPMaxMin& cpMaxMin) throw(); + /** @brief Updates the max and min casual partitioning info for the passed extents. * * @bug 1970. diff --git a/versioning/BRM/extentmap.cpp b/versioning/BRM/extentmap.cpp index dec8c1c02..61f4ac206 100644 --- a/versioning/BRM/extentmap.cpp +++ b/versioning/BRM/extentmap.cpp @@ -549,12 +549,12 @@ int ExtentMap::setMaxMin(const LBID_t lbid, } //special val to indicate a reset--used by editem -c. //Also used by COMMIT and ROLLBACK to invalidate CP. - else if (seqNum == -1) + else if (seqNum == SEQNUM_MARK_INVALID) { makeUndoRecord(&fExtentMap[i], sizeof(struct EMEntry)); // We set hiVal and loVal to correct values for signed or unsigned // during the markinvalid step, which sets the invalid variable to CP_UPDATING. - // During this step (seqNum == -1), the min and max passed in are not reliable + // During this step (seqNum == SEQNUM_MARK_INVALID), the min and max passed in are not reliable // and should not be used. fExtentMap[i].partition.cprange.isValid = CP_INVALID; incSeqNum(fExtentMap[i].partition.cprange.sequenceNum); @@ -596,7 +596,6 @@ void ExtentMap::setExtentsMaxMin(const CPMaxMinMap_t& cpMap, bool firstNode, boo #endif - #ifdef BRM_INFO if (fDebug) @@ -676,19 +675,19 @@ void ExtentMap::setExtentsMaxMin(const CPMaxMinMap_t& cpMap, bool firstNode, boo #endif } //special val to indicate a reset -- ignore the min/max - else if (it->second.seqNum == -1) + else if (it->second.seqNum == SEQNUM_MARK_INVALID) { makeUndoRecord(&fExtentMap[i], sizeof(struct EMEntry)); // We set hiVal and loVal to correct values for signed or unsigned // during the markinvalid step, which sets the invalid variable to CP_UPDATING. - // During this step (seqNum == -1), the min and max passed in are not reliable + // During this step (seqNum == SEQNUM_MARK_INVALID), the min and max passed in are not reliable // and should not be used. fExtentMap[i].partition.cprange.isValid = CP_INVALID; incSeqNum(fExtentMap[i].partition.cprange.sequenceNum); extentsUpdated++; } //special val to indicate a reset -- assign the min/max - else if (it->second.seqNum == -2) + else if (it->second.seqNum == SEQNUM_MARK_INVALID_SET_RANGE) { makeUndoRecord(&fExtentMap[i], sizeof(struct EMEntry)); if (it->second.isBinaryColumn) @@ -719,7 +718,25 @@ void ExtentMap::setExtentsMaxMin(const CPMaxMinMap_t& cpMap, bool firstNode, boo } } - throw logic_error("ExtentMap::setExtentsMaxMin(): lbid isn't allocated"); + ostringstream oss; + oss << "ExtentMap::setExtentsMaxMin(): LBIDs not allocated:"; + for (it = cpMap.begin(); it != cpMap.end(); it ++) + { + for (i = 0; i < entries; i++) + { + if (fExtentMap[i].range.start == it->first) + { + break; + } + } + if (i < entries) + { + continue; + } + oss << " " << it->first; + } + + throw logic_error(oss.str()); } //------------------------------------------------------------------------------ @@ -1166,6 +1183,47 @@ int ExtentMap::getMaxMin(const LBID_t lbid, // return -1; } +void ExtentMap::getCPMaxMin(const BRM::LBID_t lbid, BRM::CPMaxMin& cpMaxMin) +{ + int entries; + int i; + LBID_t lastBlock; + +#ifdef BRM_DEBUG + + if (lbid < 0) + throw invalid_argument("ExtentMap::getMaxMin(): lbid must be >= 0"); + +#endif + + grabEMEntryTable(READ); + entries = fEMShminfo->allocdSize / sizeof(struct EMEntry); + + for (i = 0; i < entries; i++) + { + if (fExtentMap[i].range.size != 0) + { + lastBlock = fExtentMap[i].range.start + + (static_cast(fExtentMap[i].range.size) * 1024) - 1; + + if (lbid >= fExtentMap[i].range.start && lbid <= lastBlock) + { + cpMaxMin.bigMax = fExtentMap[i].partition.cprange.bigHiVal; + cpMaxMin.bigMin = fExtentMap[i].partition.cprange.bigLoVal; + cpMaxMin.max = fExtentMap[i].partition.cprange.hiVal; + cpMaxMin.min = fExtentMap[i].partition.cprange.loVal; + cpMaxMin.seqNum = fExtentMap[i].partition.cprange.sequenceNum; + + releaseEMEntryTable(READ); + return ; + } + } + } + + releaseEMEntryTable(READ); + throw logic_error("ExtentMap::getMaxMin(): that lbid isn't allocated"); +} + /* Removes a range from the freelist. Used by load() */ void ExtentMap::reserveLBIDRange(LBID_t start, uint8_t size) { diff --git a/versioning/BRM/extentmap.h b/versioning/BRM/extentmap.h index 541709319..29b97c0be 100644 --- a/versioning/BRM/extentmap.h +++ b/versioning/BRM/extentmap.h @@ -907,6 +907,8 @@ public: template EXPORT int getMaxMin(const LBID_t lbidRange, T& max, T& min, int32_t& seqNum); + EXPORT void getCPMaxMin(const LBID_t lbidRange, CPMaxMin& cpMaxMin); /** @brief Get whole record for untyped use. */ + inline bool empty() { if (fEMShminfo == 0) diff --git a/writeengine/server/we_ddlcommandproc.cpp b/writeengine/server/we_ddlcommandproc.cpp index ad2238a6f..f78e6ebd3 100644 --- a/writeengine/server/we_ddlcommandproc.cpp +++ b/writeengine/server/we_ddlcommandproc.cpp @@ -4998,7 +4998,6 @@ void WE_DDLCommandProc::purgeFDCache() aFile.compType = aIt->compType; files.push_back(aFile); fDbrm.lookupLocalStartLbid(aFile.oid, aFile.partitionNum, aFile.segmentNum, aIt->hwm, startLbid); - lbidList.push_back(startLbid); //cout <<"Added to files oid:dbroot:part:seg:compType = " << aFile.oid<<":"<& rangeLi blockRsltnMgrPtr->endVBCopy(transID, rangeList); } +int BRMWrapper::getExtentCPMaxMin(const BRM::LBID_t lbid, BRM::CPMaxMin& cpMaxMin) +{ + int rc = blockRsltnMgrPtr->getExtentCPMaxMin(lbid, cpMaxMin); + return getRC(rc, ERR_BRM_GET_EXTENT_CP); +} + } //end of namespace // vim:ts=4 sw=4: diff --git a/writeengine/shared/we_brm.h b/writeengine/shared/we_brm.h index 897c961c4..fa4faf22a 100644 --- a/writeengine/shared/we_brm.h +++ b/writeengine/shared/we_brm.h @@ -33,6 +33,7 @@ #include "we_obj.h" #include #include "brmtypes.h" +#include "mcs_datatype.h" #include "IDBDataFile.h" #include "IDBPolicy.h" @@ -48,6 +49,42 @@ namespace WriteEngine // forward reference class DbFileOp; +/** @brief Extended CPInfo - with type handler for all type-related information */ +struct ExtCPInfo +{ + execplan::CalpontSystemCatalog::ColDataType fColType; + int fColWidth; + BRM::CPInfo fCPInfo; + ExtCPInfo(execplan::CalpontSystemCatalog::ColDataType colType, int colWidth) + : fColType(colType), fColWidth(colWidth) + { + fCPInfo.isBinaryColumn = colWidth > datatypes::MAXLEGACYWIDTH; + } + void toInvalid() + { + auto mm = datatypes::MinMaxInfo::invalidRange(fColType); + fCPInfo.max = mm.max; + fCPInfo.min = mm.min; + fCPInfo.bigMax = mm.int128Max; + fCPInfo.bigMin = mm.int128Min; + } + + bool isInvalid() + { + datatypes::MinMaxInfo mm; + mm.max = fCPInfo.max; + mm.min = fCPInfo.min; + mm.int128Max = fCPInfo.bigMax; + mm.int128Min = fCPInfo.bigMin; + return datatypes::MinMaxInfo::isRangeInvalid(mm, fColType, fColWidth); + } + bool isBinaryColumn() + { + return fCPInfo.isBinaryColumn; + } +}; +typedef std::vector ExtCPInfoList; + /** Class BRMWrapper */ class BRMWrapper : public WEObj { @@ -262,7 +299,7 @@ public: /** * @brief set extents CP min/max info into extent map */ - int setExtentsMaxMin(const BRM::CPInfoList_t& cpinfoList); + int setExtentsMaxMin(const ExtCPInfoList& cpinfoList); /** * @brief Perform bulk rollback of any column extents that logically follow @@ -473,6 +510,8 @@ public: m_useVb = val; } + int getExtentCPMaxMin(const BRM::LBID_t lbid, BRM::CPMaxMin& cpMaxMin); + private: //-------------------------------------------------------------------------- // Private methods @@ -647,9 +686,15 @@ inline int BRMWrapper::bulkSetHWMAndCP( return getRC( rc, ERR_BRM_BULK_UPDATE ); } -inline int BRMWrapper::setExtentsMaxMin(const BRM::CPInfoList_t& cpinfoList) +inline int BRMWrapper::setExtentsMaxMin(const ExtCPInfoList& extCPInfoList) { - int rc = blockRsltnMgrPtr->setExtentsMaxMin(cpinfoList); + BRM::CPInfoList_t toSet; + toSet.reserve(extCPInfoList.size()); + for (const auto& extCPInfo : extCPInfoList) + { + toSet.push_back(extCPInfo.fCPInfo); + } + int rc = blockRsltnMgrPtr->setExtentsMaxMin(toSet); return getRC( rc, ERR_BRM_SET_EXTENTS_CP ); } diff --git a/writeengine/shared/we_define.cpp b/writeengine/shared/we_define.cpp index 704600f60..d0774ba58 100644 --- a/writeengine/shared/we_define.cpp +++ b/writeengine/shared/we_define.cpp @@ -206,6 +206,7 @@ WErrorCodes::WErrorCodes() : fErrorCodes() fErrorCodes[ERR_BRM_GET_SUSPEND] = " BRM error get the system suspend flag "; fErrorCodes[ERR_BRM_BAD_STRIPE_CNT] = " Incorrect number of column extents allocated in stripe"; fErrorCodes[ERR_BRM_UNSUPP_WIDTH] = " Unsupported non-dictionary column width"; + fErrorCodes[ERR_BRM_GET_EXTENT_CP] = " BRM error getting extent max/min"; // DM error fErrorCodes[ERR_DM_CONVERT_OID] = " a DM Conversion error"; diff --git a/writeengine/shared/we_define.h b/writeengine/shared/we_define.h index 03c7783ff..97ae3a1b2 100644 --- a/writeengine/shared/we_define.h +++ b/writeengine/shared/we_define.h @@ -311,6 +311,7 @@ const int ERR_BRM_SUSPEND = ERR_BRMBASE + 44;// BRM is set to Suspend const int ERR_BRM_GET_SUSPEND = ERR_BRMBASE + 45;// error getting BRM Suspend flag const int ERR_BRM_BAD_STRIPE_CNT = ERR_BRMBASE + 46;// Incorrect num of cols allocated in stripe const int ERR_BRM_UNSUPP_WIDTH = ERR_BRMBASE + 47;// Non-dict column Width > allowed MAX. +const int ERR_BRM_GET_EXTENT_CP = ERR_BRMBASE + 48;// Error getting extent's CPInfo //-------------------------------------------------------------------------- // DM error diff --git a/writeengine/shared/we_type.h b/writeengine/shared/we_type.h index 791b568d7..40d9a828e 100644 --- a/writeengine/shared/we_type.h +++ b/writeengine/shared/we_type.h @@ -34,6 +34,7 @@ #include #include +#include "brm.h" #include "we_define.h" #include "we_typeext.h" #include "calpontsystemcatalog.h" diff --git a/writeengine/wrapper/we_colop.cpp b/writeengine/wrapper/we_colop.cpp index 96349651e..5a351c260 100644 --- a/writeengine/wrapper/we_colop.cpp +++ b/writeengine/wrapper/we_colop.cpp @@ -82,7 +82,8 @@ ColumnOp::~ColumnOp() * tableFid - the file id for table bitmap file * totalRow - the total number of rows need to be allocated * useStartingExtent - Indicates whether rows can be added to an existing -* starting extent + * starting extent + * newExtents - where to write extents allocated for newColStructList, etc, structures. * RETURN: * NO_ERROR if success * rowIdArray - allocation of the row id left here @@ -90,7 +91,7 @@ ColumnOp::~ColumnOp() int ColumnOp::allocRowId(const TxnID& txnid, bool useStartingExtent, Column& column, uint64_t totalRow, RID* rowIdArray, HWM& hwm, bool& newExtent, uint64_t& rowsLeft, HWM& newHwm, bool& newFile, ColStructList& newColStructList, DctnryStructList& newDctnryStructList, std::vector >& dbRootExtentTrackers, - bool insertSelect, bool isBatchInsert, OID tableOid, bool isFirstBatchPm) + bool insertSelect, bool isBatchInsert, OID tableOid, bool isFirstBatchPm, std::vector* newExtents) { //MultiFiles per OID: always append the rows to the end for now. // See if the current HWM block might be in an abbreviated extent that @@ -379,6 +380,10 @@ int ColumnOp::allocRowId(const TxnID& txnid, bool useStartingExtent, newDctnryStructList[i].fColSegment = segment; newDctnryStructList[i].fColDbRoot = dbRoot; lbids.push_back(extents[i].startLbid); + if (newExtents) + { + (*newExtents).push_back(extents[i].startLbid); + } colDataTypes.push_back(newColStructList[i].colDataType); } @@ -963,7 +968,7 @@ int ColumnOp::fillColumn(const TxnID& txnid, Column& column, Column& refCol, voi refBufOffset = BYTE_PER_BLOCK; colBufOffset = BYTE_PER_BLOCK; dirty = false; - BRM::CPInfo cpInfo; + ExtCPInfo cpInfo(column.colDataType, column.colWidth); if (autoincrement) { @@ -1048,19 +1053,17 @@ int ColumnOp::fillColumn(const TxnID& txnid, Column& column, Column& refCol, voi } } - cpInfo.isBinaryColumn = column.colWidth > 8; - - if (!cpInfo.isBinaryColumn) + if (!cpInfo.isBinaryColumn()) { - cpInfo.max = nextValStart + nexValNeeded - 1; - cpInfo.min = nextValStart; + cpInfo.fCPInfo.max = nextValStart + nexValNeeded - 1; + cpInfo.fCPInfo.min = nextValStart; } else { - cpInfo.bigMax = nextValStart + nexValNeeded - 1; - cpInfo.bigMin = nextValStart; + cpInfo.fCPInfo.bigMax = nextValStart + nexValNeeded - 1; + cpInfo.fCPInfo.bigMin = nextValStart; } - cpInfo.seqNum = 0; + cpInfo.fCPInfo.seqNum = 0; } else @@ -1113,36 +1116,9 @@ int ColumnOp::fillColumn(const TxnID& txnid, Column& column, Column& refCol, voi } } - cpInfo.isBinaryColumn = column.colWidth > 8; + cpInfo.toInvalid(); - if (!cpInfo.isBinaryColumn) - { - if (isUnsigned(column.colDataType)) - { - cpInfo.max = 0; - cpInfo.min = static_cast(numeric_limits::max()); - } - else - { - cpInfo.max = numeric_limits::min(); - cpInfo.min = numeric_limits::max(); - } - } - else - { - if (isUnsigned(column.colDataType)) - { - cpInfo.bigMax = 0; - cpInfo.min = -1; - } - else - { - utils::int128Min(cpInfo.bigMax); - utils::int128Max(cpInfo.bigMin); - } - } - - cpInfo.seqNum = -1; + cpInfo.fCPInfo.seqNum = SEQNUM_MARK_INVALID; } if (dirty) @@ -1165,39 +1141,11 @@ int ColumnOp::fillColumn(const TxnID& txnid, Column& column, Column& refCol, voi if (autoincrement) //@Bug 4074. Mark it invalid first to set later { - BRM::CPInfo cpInfo1; - cpInfo1.isBinaryColumn = column.colWidth > 8; - - if (!cpInfo1.isBinaryColumn) - { - if (isUnsigned(column.colDataType)) - { - cpInfo1.max = 0; - cpInfo1.min = static_cast(numeric_limits::max()); - } - else - { - cpInfo1.max = numeric_limits::min(); - cpInfo1.min = numeric_limits::max(); - } - } - else - { - if (isUnsigned(column.colDataType)) - { - cpInfo1.bigMax = 0; - cpInfo1.bigMin = -1; - } - else - { - utils::int128Min(cpInfo1.bigMax); - utils::int128Max(cpInfo1.bigMin); - } - } - - cpInfo1.seqNum = -1; - cpInfo1.firstLbid = startLbid; - BRM::CPInfoList_t cpinfoList1; + ExtCPInfo cpInfo1(column.colDataType, column.colWidth); + cpInfo1.toInvalid(); + cpInfo1.fCPInfo.seqNum = SEQNUM_MARK_INVALID; + cpInfo1.fCPInfo.firstLbid = startLbid; + ExtCPInfoList cpinfoList1; cpinfoList1.push_back(cpInfo1); rc = BRMWrapper::getInstance()->setExtentsMaxMin(cpinfoList1); @@ -1205,8 +1153,8 @@ int ColumnOp::fillColumn(const TxnID& txnid, Column& column, Column& refCol, voi return rc; } - BRM::CPInfoList_t cpinfoList; - cpInfo.firstLbid = startLbid; + ExtCPInfoList cpinfoList; + cpInfo.fCPInfo.firstLbid = startLbid; cpinfoList.push_back(cpInfo); rc = BRMWrapper::getInstance()->setExtentsMaxMin(cpinfoList); @@ -1627,7 +1575,7 @@ void ColumnOp::setColParam(Column& column, * RETURN: * NO_ERROR if success, other number otherwise ***********************************************************/ -int ColumnOp::writeRow(Column& curCol, uint64_t totalRow, const RID* rowIdArray, const void* valArray, bool bDelete ) +int ColumnOp::writeRow(Column& curCol, uint64_t totalRow, const RID* rowIdArray, const void* valArray, void* oldValArray, bool bDelete ) { uint64_t i = 0, curRowId; int dataFbo, dataBio, curDataFbo = -1; @@ -1748,6 +1696,12 @@ int ColumnOp::writeRow(Column& curCol, uint64_t totalRow, const RID* rowIdArray, } // This is the write stuff + if (oldValArray) + { + uint8_t* p = static_cast(oldValArray); + memcpy(p + curCol.colWidth * i, dataBuf + dataBio, curCol.colWidth); + } + writeBufValue(dataBuf + dataBio, pVal, curCol.colWidth); i++; @@ -1780,7 +1734,7 @@ int ColumnOp::writeRow(Column& curCol, uint64_t totalRow, const RID* rowIdArray, * RETURN: * NO_ERROR if success, other number otherwise ***********************************************************/ -int ColumnOp::writeRows(Column& curCol, uint64_t totalRow, const RIDList& ridList, const void* valArray, const void* oldValArray, bool bDelete ) +int ColumnOp::writeRows(Column& curCol, uint64_t totalRow, const RIDList& ridList, const void* valArray, void* oldValArray, bool bDelete ) { uint64_t i = 0, curRowId; int dataFbo, dataBio, curDataFbo = -1; @@ -1895,6 +1849,13 @@ int ColumnOp::writeRows(Column& curCol, uint64_t totalRow, const RIDList& ridLis curCol.colWidth); } + // This is the write stuff + if (oldValArray) + { + uint8_t* p = static_cast(oldValArray); + memcpy(p + i * curCol.colWidth, dataBuf + dataBio, curCol.colWidth); + } + writeBufValue(dataBuf + dataBio, pVal, curCol.colWidth); i++; @@ -1927,7 +1888,7 @@ int ColumnOp::writeRows(Column& curCol, uint64_t totalRow, const RIDList& ridLis * RETURN: * NO_ERROR if success, other number otherwise ***********************************************************/ -int ColumnOp::writeRowsValues(Column& curCol, uint64_t totalRow, const RIDList& ridList, const void* valArray ) +int ColumnOp::writeRowsValues(Column& curCol, uint64_t totalRow, const RIDList& ridList, const void* valArray, void* oldValArray) { uint64_t i = 0, curRowId; int dataFbo, dataBio, curDataFbo = -1; @@ -2035,6 +1996,12 @@ int ColumnOp::writeRowsValues(Column& curCol, uint64_t totalRow, const RIDList& } // This is the write stuff + if (oldValArray) + { + uint8_t* p = static_cast(oldValArray); + memcpy(p + curCol.colWidth * i, dataBuf + dataBio, curCol.colWidth); + } + writeBufValue(dataBuf + dataBio, pVal, curCol.colWidth); i++; diff --git a/writeengine/wrapper/we_colop.h b/writeengine/wrapper/we_colop.h index 8735c3c36..51555c45f 100644 --- a/writeengine/wrapper/we_colop.h +++ b/writeengine/wrapper/we_colop.h @@ -73,9 +73,10 @@ public: ColStructList& newColStructList, DctnryStructList& newDctnryStructList, std::vector >& dbRootExtentTrackers, - bool insertSelect = false, - bool isBatchInsert = false, - OID tableOid = 0, bool isFirstBatchPm = false); + bool insertSelect, + bool isBatchInsert, + OID tableOid, bool isFirstBatchPm, + std::vector* newEtents); /** * @brief Create column file(s) @@ -266,6 +267,7 @@ public: uint64_t totalRow, const RID* rowIdArray, const void* valArray, + void* oldValArray =0, bool bDelete = false); /** @@ -275,7 +277,7 @@ public: uint64_t totalRow, const RIDList& ridList, const void* valArray, - const void* oldValArray = 0, + void* oldValArray = 0, bool bDelete = false); /** @@ -284,7 +286,8 @@ public: EXPORT virtual int writeRowsValues(Column& curCol, uint64_t totalRow, const RIDList& ridList, - const void* valArray); + const void* valArray, + void* oldValArray = 0); /** * @brief Test if the pFile is an abbreviated extent. diff --git a/writeengine/wrapper/writeengine.cpp b/writeengine/wrapper/writeengine.cpp index a350fc331..2fefb8328 100644 --- a/writeengine/wrapper/writeengine.cpp +++ b/writeengine/wrapper/writeengine.cpp @@ -1,5 +1,5 @@ /* Copyright (C) 2014 InfiniDB, Inc. - Copyright (C) 2016-2019 MariaDB Corporation + Copyright (C) 2016-2021 MariaDB Corporation This program is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License @@ -66,11 +66,11 @@ using namespace idbdatafile; namespace WriteEngine //#define PROFILE 1 +#define RETURN_ON_ERROR_REPORT(statement) do { int rc = (statement); if (rc != NO_ERROR) { cerr << "failed at " << __LINE__ << "function " << __FUNCTION__ << ", statement '" << #statement << "', rc " << rc << endl; return rc; } } while (0) + { StopWatch timer; -static BRM::CPInfo dummyCPInfo; - /**@brief WriteEngineWrapper Constructor */ WriteEngineWrapper::WriteEngineWrapper() : m_opType(NOOP) @@ -220,6 +220,212 @@ void WriteEngineWrapper::findSmallestColumn(uint32_t& colId, ColStructList colSt } } +/** @brief Fetch values from arrays into VT-types references casting arrays to (element type) ET-typed arrays. + * + * There might be two arrays: one from which we write to buffer and one with old values written before. + * One of these arrays can be absent because of, well, physical absence. Insertion does not have + * values written before and deletion does not have values to write to. + */ +template +void fetchNewOldValues(VT& value, VT& oldValue, const void* array, const void* oldArray, size_t i, size_t totalNewRow) +{ + const ET* eArray = static_cast(array); + const ET* oldEArray = static_cast(oldArray); + if (eArray) + { + value = eArray[i < totalNewRow ? i : 0]; + } + if (oldEArray) + { + oldValue = oldEArray[i]; + } +} + +static bool updateBigRangeCheckForInvalidity(ExtCPInfo* maxMin, int128_t value, int128_t oldValue, const void* valArrayVoid, const void* oldValArrayVoid) +{ + if (!oldValArrayVoid) + { // insertion. we can update range directly. range will not become invalid here. + maxMin->fCPInfo.bigMax = std::max(maxMin->fCPInfo.bigMax, value); // we update big range because int columns can be associated with decimals. + maxMin->fCPInfo.bigMin = std::min(maxMin->fCPInfo.bigMin, value); + } + else if (!valArrayVoid) + { // deletion. we need to check old value only, is it on (or outside) range boundary. + if (oldValue >= maxMin->fCPInfo.bigMax || oldValue <= maxMin->fCPInfo.bigMin) + { + maxMin->toInvalid(); + return true; // no point working further. + } + } + else if (valArrayVoid && oldValArrayVoid) + { // update. we need to check boundaries as in deletion and extend as in insertion. + // check boundaries as in deletion accounting for possible extension. + if ( (oldValue <= maxMin->fCPInfo.bigMin && value > oldValue) + || (oldValue >= maxMin->fCPInfo.bigMax && value < oldValue)) + { // we are overwriting value on the boundary with value that does not preserve or extend range. + maxMin->toInvalid(); + return true; + } + maxMin->fCPInfo.bigMax = std::max(maxMin->fCPInfo.bigMax, value); + maxMin->fCPInfo.bigMin = std::min(maxMin->fCPInfo.bigMin, value); + } + return false; +} + + +template +bool updateRangeCheckForInvalidity(ExtCPInfo* maxMin, InternalType value, InternalType oldValue, const void* valArrayVoid, const void* oldValArrayVoid) +{ + if (!oldValArrayVoid) + { // insertion. we can update range directly. range will not become invalid here. + maxMin->fCPInfo.bigMax = std::max(maxMin->fCPInfo.bigMax, (int128_t)value); // we update big range because int columns can be associated with decimals. + maxMin->fCPInfo.bigMin = std::min(maxMin->fCPInfo.bigMin, (int128_t)value); + maxMin->fCPInfo.max = std::max((InternalType)maxMin->fCPInfo.max, value); + maxMin->fCPInfo.min = std::min((InternalType)maxMin->fCPInfo.min, value); + } + else if (!valArrayVoid) + { // deletion. we need to check old value only, is it on (or outside) range boundary. + if (oldValue >= (InternalType)maxMin->fCPInfo.max || oldValue <= (InternalType)maxMin->fCPInfo.min) + { + maxMin->toInvalid(); + return true; // no point working further. + } + } + else if (valArrayVoid && oldValArrayVoid) + { // update. we need to check boundaries as in deletion and extend as in insertion. + // check boundaries as in deletion accounting for possible extension. + if ( (oldValue <= (InternalType)maxMin->fCPInfo.min && value > oldValue) + || (oldValue >= (InternalType)maxMin->fCPInfo.max && value < oldValue)) + { // we are overwriting value on the boundary with value that does not preserve or extend range. + maxMin->toInvalid(); + return true; + } + maxMin->fCPInfo.bigMax = std::max(maxMin->fCPInfo.bigMax, (int128_t)value); + maxMin->fCPInfo.bigMin = std::min(maxMin->fCPInfo.bigMin, (int128_t)value); + maxMin->fCPInfo.max = std::max((InternalType)maxMin->fCPInfo.max, value); + maxMin->fCPInfo.min = std::min((InternalType)maxMin->fCPInfo.min, value); + } + return false; +} + +/** + * There can be case with missing valArray (delete), missing oldValArray (insert) and when + * both arrays are present (update). + */ +void WriteEngineWrapper::updateMaxMinRange(const size_t totalNewRow, const size_t totalOldRow, + const execplan::CalpontSystemCatalog::ColType& cscColType, + const ColType colType, + const void* valArrayVoid, const void* oldValArrayVoid, + ExtCPInfo* maxMin, bool canStartWithInvalidRange) +{ + if (!maxMin) + { + return ; + } + bool isUnsigned = false; // TODO: should change with type. + switch (colType) + { + case WR_UBYTE: + case WR_USHORT: + case WR_UINT: + case WR_ULONGLONG: + { + isUnsigned = true; + break; + } + default: // WR_BINARY is signed. + break; + } + if (!canStartWithInvalidRange) + { + // check if range is invalid, we can't update it. + if (maxMin->isInvalid()) + { + return ; + } + } + size_t i; + for (i = 0; i < totalOldRow; i++) { + int64_t value = 0, oldValue = 0; + uint64_t uvalue = 0, oldUValue = 0; + int128_t bvalue = 0, oldBValue = 0; + + // fetching. May not assign value or oldValue variables when array is not present. + switch (colType) + { + case WR_BYTE: + { + fetchNewOldValues(value, oldValue, valArrayVoid, oldValArrayVoid, i, totalNewRow); + break; + } + case WR_UBYTE: + { + fetchNewOldValues(uvalue, oldUValue, valArrayVoid, oldValArrayVoid, i, totalNewRow); + break; + } + case WR_SHORT: + { + fetchNewOldValues(value, oldValue, valArrayVoid, oldValArrayVoid, i, totalNewRow); + break; + } + case WR_USHORT: + { + fetchNewOldValues(uvalue, oldUValue, valArrayVoid, oldValArrayVoid, i, totalNewRow); + break; + } + case WR_MEDINT: + case WR_INT: + { + fetchNewOldValues(value, oldValue, valArrayVoid, oldValArrayVoid, i, totalNewRow); + break; + } + case WR_UMEDINT: + case WR_UINT: + { + fetchNewOldValues(uvalue, oldUValue, valArrayVoid, oldValArrayVoid, i, totalNewRow); + break; + } + case WR_LONGLONG: + { + fetchNewOldValues(value, oldValue, valArrayVoid, oldValArrayVoid, i, totalNewRow); + break; + } + case WR_ULONGLONG: + { + fetchNewOldValues(uvalue, oldUValue, valArrayVoid, oldValArrayVoid, i, totalNewRow); + break; + } + case WR_BINARY: + { + fetchNewOldValues(bvalue, oldBValue, valArrayVoid, oldValArrayVoid, i, totalNewRow); + break; + } + default: + idbassert(0 && "unknown WR type tag"); + return; + } + if (maxMin->isBinaryColumn()) + { // special case of wide decimals. They fit into int128_t range so we do not care about signedness. + if (updateBigRangeCheckForInvalidity(maxMin, bvalue, oldBValue, valArrayVoid, oldValArrayVoid)) + { + return ; + } + } + else if (isUnsigned) + { + if (updateRangeCheckForInvalidity(maxMin, uvalue, oldUValue, valArrayVoid, oldValArrayVoid)) + { + return ; + } + } + else + { + if (updateRangeCheckForInvalidity(maxMin, value, oldValue, valArrayVoid, oldValArrayVoid)) + { + return ; + } + } + } +} /*@convertValArray - Convert interface values to internal values */ /*********************************************************** @@ -244,7 +450,7 @@ void WriteEngineWrapper::convertValArray(const size_t totalRow, const CalpontSys for (i = 0; i < curTupleList.size(); i++) { curTuple = curTupleList[i]; - convertValue(cscColType, colType, valArray, i, curTuple.data); + convertValue(cscColType, colType, valArray, i, curTuple.data, true); } } else @@ -413,7 +619,6 @@ void WriteEngineWrapper::convertValue(const execplan::CalpontSystemCatalog::ColT } // end of switch (colType) } /*@convertValue - The base for converting values */ - /*********************************************************** * DESCRIPTION: * The base for converting values @@ -434,12 +639,16 @@ void WriteEngineWrapper::convertValue(const CalpontSystemCatalog::ColType& cscCo { case WriteEngine::WR_INT : case WriteEngine::WR_MEDINT : + // here we assign value to an array element and update range. if (data.type() == typeid(long)) - ((int*)valArray)[pos] = static_cast(boost::any_cast(data)); + ((int*)valArray)[pos] = static_cast(boost::any_cast(data)); else if (data.type() == typeid(int)) - ((int*)valArray)[pos] = boost::any_cast(data); + ((int*)valArray)[pos] = boost::any_cast(data); else + { // this interesting part is for magic values like NULL or EMPTY (marks deleted elements). + // we will not put these into range. ((int*)valArray)[pos] = boost::any_cast(data); + } break; @@ -673,7 +882,7 @@ int WriteEngineWrapper::fillColumn(const TxnID& txnid, const OID& dataOid, Dctnry* dctnry = m_dctnry[op(compressionType)]; colOpNewCol->initColumn(newCol); refColOp->initColumn(refCol); - uint16_t dbRoot = 1; //not to be used + uint16_t dbRoot = 1; //not to be used int newDataWidth = colType.colWidth; //Convert HWM of the reference column for the new column //Bug 1703,1705 @@ -848,6 +1057,8 @@ int WriteEngineWrapper::deleteBadRows(const TxnID& txnid, ColStructList& colStru Column curCol; void* valArray = NULL; + m_opType = DELETE; + for (unsigned i = 0; i < colStructs.size(); i++) { ColumnOp* colOp = m_colOp[op(colStructs[i].fCompressionType)]; @@ -953,6 +1164,58 @@ static void log_this(const char *message, } #endif +/** @brief Determine whether we may update a column's ranges (by type) and return nullptr if we can't */ +static ExtCPInfo* +getCPInfoToUpdateForUpdatableType(const ColStruct& colStruct, ExtCPInfo* currentCPInfo) +{ + if (colStruct.tokenFlag) + { + return nullptr; + } + switch(colStruct.colDataType) + { + // here we enumerate all supported types. + case CalpontSystemCatalog::TINYINT: + case CalpontSystemCatalog::SMALLINT: + case CalpontSystemCatalog::DECIMAL: + case CalpontSystemCatalog::MEDINT: + case CalpontSystemCatalog::INT: + case CalpontSystemCatalog::BIGINT: + case CalpontSystemCatalog::UTINYINT: + case CalpontSystemCatalog::USMALLINT: + case CalpontSystemCatalog::UDECIMAL: + case CalpontSystemCatalog::UMEDINT: + case CalpontSystemCatalog::UINT: + case CalpontSystemCatalog::UBIGINT: + { + return currentCPInfo; + } + // all unsupported types must not be supported. + default: + return nullptr; // safe choice for everything we can't do. + } +} + +/** @brief Let only valid ranges to be present. + * + * There can be a case that we have computed invalid range while computing updated ranges. + * + * These invalid ranges should not have CP_VALID in the status code. So, they must not + * come into final call to setCPInfos or something. + * + * To achieve that, we filter these invalid ranges here. + */ +static void +setInvalidCPInfosSpecialMarks(std::vector& cpInfos) +{ + size_t i; + for(i=0; i < cpInfos.size(); i++) { + if (cpInfos[i].isInvalid()) + { + cpInfos[i].fCPInfo.seqNum = SEQNUM_MARK_INVALID_SET_RANGE; + } + } +} /*@insertColumnRecs - Insert value(s) into a column */ @@ -992,17 +1255,20 @@ int WriteEngineWrapper::insertColumnRecs(const TxnID& txnid, DctnryStructList newDctnryStructList; HWM hwm = 0; HWM oldHwm = 0; - HWM newHwm = 0; + HWM newHwm = 0; ColTupleList::size_type totalRow; ColStructList::size_type totalColumns; uint64_t rowsLeft = 0; bool newExtent = false; RIDList ridList; ColumnOp* colOp = NULL; + ColSplitMaxMinInfoList maxMins; // Set tmp file suffix to modify HDFS db file bool useTmpSuffix = false; + m_opType = INSERT; + if (idbdatafile::IDBPolicy::useHdfs()) { if (!bFirstExtentOnThisPM) @@ -1026,6 +1292,12 @@ int WriteEngineWrapper::insertColumnRecs(const TxnID& txnid, for (i = 0; i < colStructList.size(); i++) Convertor::convertColType(&colStructList[i]); + for (const auto& colStruct : colStructList) + { + ColSplitMaxMinInfo tmp(colStruct.colDataType, colStruct.colWidth); + maxMins.push_back(tmp); + } + uint32_t colId = 0; // MCOL-1675: find the smallest column width to calculate the RowID from so // that all HWMs will be incremented by this operation @@ -1045,7 +1317,8 @@ int WriteEngineWrapper::insertColumnRecs(const TxnID& txnid, IDBDataFile* pFile = NULL; std::vector extentInfo; int currentDBrootIdx = 0; - std::vector extents; + std::vector extents; // this structure valid only when isFirstOnBatchPm is true. + std::vector newExtentsStartingLbids; // we keep column-indexed LBIDs here for **new** extents. It is set and valid and used only when rowsLeft > 0. //-------------------------------------------------------------------------- // For first batch on this PM: @@ -1057,8 +1330,8 @@ int WriteEngineWrapper::insertColumnRecs(const TxnID& txnid, //-------------------------------------------------------------------------- if (isFirstBatchPm) { - currentDBrootIdx = dbRootExtentTrackers[colId]->getCurrentDBRootIdx(); - extentInfo = dbRootExtentTrackers[colId]->getDBRootExtentList(); + currentDBrootIdx = dbRootExtentTrackers[colId]->getCurrentDBRootIdx(); + extentInfo = dbRootExtentTrackers[colId]->getDBRootExtentList(); dbRoot = extentInfo[currentDBrootIdx].fDbRoot; partitionNum = extentInfo[currentDBrootIdx].fPartition; @@ -1084,11 +1357,11 @@ int WriteEngineWrapper::insertColumnRecs(const TxnID& txnid, return rc; //Create column files - BRM::CPInfoList_t cpinfoList; - BRM::CPInfo cpInfo; + ExtCPInfoList cpinfoList; for ( i = 0; i < extents.size(); i++) { + ExtCPInfo cpInfo(colStructList[i].colDataType, colStructList[i].colWidth); colOp = m_colOp[op(colStructList[i].fCompressionType)]; colOp->initColumn(curCol); colOp->setColParam(curCol, colId, colStructList[i].colWidth, colStructList[i].colDataType, @@ -1102,39 +1375,12 @@ int WriteEngineWrapper::insertColumnRecs(const TxnID& txnid, if (rc != NO_ERROR) return rc; - cpInfo.isBinaryColumn = colStructList[i].colWidth > 8; + cpInfo.toInvalid(); - if (!cpInfo.isBinaryColumn) - { - if (isUnsigned(colStructList[i].colDataType)) - { - cpInfo.max = 0; - cpInfo.min = static_cast(numeric_limits::max()); - } - else - { - cpInfo.max = numeric_limits::min(); - cpInfo.min = numeric_limits::max(); - } - } - else - { - if (isUnsigned(colStructList[i].colDataType)) - { - cpInfo.bigMax = 0; - cpInfo.bigMin = -1; - } - else - { - utils::int128Min(cpInfo.bigMax); - utils::int128Max(cpInfo.bigMin); - } - } - - cpInfo.seqNum = -1; + cpInfo.fCPInfo.seqNum = SEQNUM_MARK_INVALID_SET_RANGE; //mark the extents to invalid - cpInfo.firstLbid = extents[i].startLbid; + cpInfo.fCPInfo.firstLbid = extents[i].startLbid; cpinfoList.push_back(cpInfo); colStructList[i].fColPartition = partitionNum; colStructList[i].fColSegment = segmentNum; @@ -1355,7 +1601,7 @@ int WriteEngineWrapper::insertColumnRecs(const TxnID& txnid, rc = colOp->allocRowId(txnid, bUseStartExtent, curCol, (uint64_t)totalRow, rowIdArray, hwm, newExtent, rowsLeft, newHwm, newFile, - newColStructList, newDctnryStructList, dbRootExtentTrackers, insertSelect, true, tableOid, isFirstBatchPm); + newColStructList, newDctnryStructList, dbRootExtentTrackers, insertSelect, true, tableOid, isFirstBatchPm, &newExtentsStartingLbids); if (rc != NO_ERROR) //Clean up is already done return rc; @@ -1376,9 +1622,9 @@ int WriteEngineWrapper::insertColumnRecs(const TxnID& txnid, { for (unsigned k=0; ksetColParam(expandCol, 0, @@ -1690,24 +1936,42 @@ int WriteEngineWrapper::insertColumnRecs(const TxnID& txnid, int curFbo = 0, curBio, lastFbo = -1; if (isFirstBatchPm && (totalRow == rowsLeft)) - {} + { + // in this particular case we already marked extents as invalid up there. + } else { + int firstHalfCount = totalRow - rowsLeft; for (unsigned i = 0; i < colStructList.size(); i++) { colOp = m_colOp[op(colStructList[i].fCompressionType)]; width = colStructList[i].colWidth; - successFlag = colOp->calculateRowId(lastRid, BYTE_PER_BLOCK / width, width, curFbo, curBio); - - if (successFlag) + if (firstHalfCount) { - if (curFbo != lastFbo) + ExtCPInfo* cpInfoP = getCPInfoToUpdateForUpdatableType(colStructList[i], &maxMins[i].fSplitMaxMinInfo[0]); + RID thisRid = rowsLeft ? lastRid : lastRidNew; + successFlag = colOp->calculateRowId(thisRid, BYTE_PER_BLOCK / width, width, curFbo, curBio); + + if (successFlag) { - RETURN_ON_ERROR(AddLBIDtoList(txnid, - colStructList[i], - curFbo, - dummyCPInfo)); + if (curFbo != lastFbo) + { + RETURN_ON_ERROR(AddLBIDtoList(txnid, + colStructList[i], + curFbo, cpInfoP)); + } } + maxMins[i].fSplitMaxMinInfoPtrs[0] = cpInfoP; + } + if (rowsLeft) + { + ExtCPInfo* cpInfoP = getCPInfoToUpdateForUpdatableType(colStructList[i], &maxMins[i].fSplitMaxMinInfo[1]); + if (cpInfoP) + { + RETURN_ON_ERROR(GetLBIDRange(newExtentsStartingLbids[i], colStructList[i], *cpInfoP)); + } + + maxMins[i].fSplitMaxMinInfoPtrs[1] = cpInfoP; } } } @@ -1717,7 +1981,25 @@ int WriteEngineWrapper::insertColumnRecs(const TxnID& txnid, //---------------------------------------------------------------------- // Write row(s) to database file(s) //---------------------------------------------------------------------- - rc = writeColumnRec(txnid, cscColTypeList, colStructList, colOldValueList, rowIdArray, newColStructList, colNewValueList, tableOid, useTmpSuffix); // @bug 5572 HDFS tmp file + std::vector cpinfoList; + for (auto& splitCPInfo : maxMins) + { + for (i = 0; i < 2; i ++) + { + ExtCPInfo* cpInfo = splitCPInfo.fSplitMaxMinInfoPtrs[i]; + if (cpInfo) + { + cpinfoList.push_back(*cpInfo); + cpinfoList[cpinfoList.size() - 1].fCPInfo.seqNum = SEQNUM_MARK_INVALID_SET_RANGE; + } + } + } + rc = BRMWrapper::getInstance()->setExtentsMaxMin(cpinfoList); + if (rc != NO_ERROR) + { + return rc; + } + rc = writeColumnRec(txnid, cscColTypeList, colStructList, colOldValueList, rowIdArray, newColStructList, colNewValueList, tableOid, useTmpSuffix, true, &maxMins); // @bug 5572 HDFS tmp file if (rc == NO_ERROR) { @@ -1734,7 +2016,28 @@ int WriteEngineWrapper::insertColumnRecs(const TxnID& txnid, if (rc != 0) rc = ERR_BLKCACHE_FLUSH_LIST; // translate to WE error } - } + + if (rc == NO_ERROR) + { + int index = 0; + for (auto& splitCPInfo : maxMins) + { + for (i = 0; i < 2; i ++) + { + ExtCPInfo* cpInfo = splitCPInfo.fSplitMaxMinInfoPtrs[i]; + if (cpInfo) + { + cpinfoList[index] = *cpInfo; + cpinfoList[index].fCPInfo.seqNum ++; + index ++; + } + } + } + setInvalidCPInfosSpecialMarks(cpinfoList); + rc = BRMWrapper::getInstance()->setExtentsMaxMin(cpinfoList); + } + + } } return rc; @@ -1762,7 +2065,7 @@ int WriteEngineWrapper::insertColumnRecsBinary(const TxnID& txnid, DctnryStructList newDctnryStructList; HWM hwm = 0; HWM oldHwm = 0; - HWM newHwm = 0; + HWM newHwm = 0; size_t totalRow; ColStructList::size_type totalColumns; uint64_t rowsLeft = 0; @@ -1774,6 +2077,8 @@ int WriteEngineWrapper::insertColumnRecsBinary(const TxnID& txnid, // Set tmp file suffix to modify HDFS db file bool useTmpSuffix = false; + m_opType = INSERT; + if (idbdatafile::IDBPolicy::useHdfs()) { if (!bFirstExtentOnThisPM) @@ -1849,11 +2154,11 @@ int WriteEngineWrapper::insertColumnRecsBinary(const TxnID& txnid, return rc; //Create column files - BRM::CPInfoList_t cpinfoList; - BRM::CPInfo cpInfo; + ExtCPInfoList cpinfoList; for ( i = 0; i < extents.size(); i++) { + ExtCPInfo cpInfo(colStructList[i].colDataType, colStructList[i].colWidth); colOp = m_colOp[op(colStructList[i].fCompressionType)]; colOp->initColumn(curCol); colOp->setColParam(curCol, 0, colStructList[i].colWidth, colStructList[i].colDataType, @@ -1867,39 +2172,12 @@ int WriteEngineWrapper::insertColumnRecsBinary(const TxnID& txnid, if (rc != NO_ERROR) return rc; - cpInfo.isBinaryColumn = colStructList[i].colWidth > 8; + cpInfo.toInvalid(); - if (!cpInfo.isBinaryColumn) - { - if (isUnsigned(colStructList[i].colDataType)) - { - cpInfo.max = 0; - cpInfo.min = static_cast(numeric_limits::max()); - } - else - { - cpInfo.max = numeric_limits::min(); - cpInfo.min = numeric_limits::max(); - } - } - else - { - if (isUnsigned(colStructList[i].colDataType)) - { - cpInfo.bigMax = 0; - cpInfo.bigMin = -1; - } - else - { - utils::int128Min(cpInfo.bigMax); - utils::int128Max(cpInfo.bigMin); - } - } - - cpInfo.seqNum = -1; + cpInfo.fCPInfo.seqNum = SEQNUM_MARK_INVALID_SET_RANGE; //mark the extents to invalid - cpInfo.firstLbid = extents[i].startLbid; + cpInfo.fCPInfo.firstLbid = extents[i].startLbid; cpinfoList.push_back(cpInfo); colStructList[i].fColPartition = partitionNum; colStructList[i].fColSegment = segmentNum; @@ -2124,7 +2402,7 @@ int WriteEngineWrapper::insertColumnRecsBinary(const TxnID& txnid, rc = colOp->allocRowId(txnid, bUseStartExtent, curCol, (uint64_t)totalRow, rowIdArray, hwm, newExtent, rowsLeft, newHwm, newFile, - newColStructList, newDctnryStructList, dbRootExtentTrackers, insertSelect, true, tableOid, isFirstBatchPm); + newColStructList, newDctnryStructList, dbRootExtentTrackers, insertSelect, true, tableOid, isFirstBatchPm, NULL); //cout << "after allocrowid, total row = " <allocRowId(txnid, bUseStartExtent, curCol, (uint64_t)totalRow, rowIdArray, hwm, newExtent, rowsLeft, newHwm, newFile, newColStructList, newDctnryStructList, - dbRootExtentTrackers, false, false, 0); + dbRootExtentTrackers, false, false, 0, false, NULL); if ((rc == ERR_FILE_DISK_SPACE) && newExtent) { @@ -3060,8 +3338,7 @@ int WriteEngineWrapper::insertColumnRec_SYS(const TxnID& txnid, { RETURN_ON_ERROR(AddLBIDtoList(txnid, colStructList[i], - curFbo, - dummyCPInfo)); + curFbo)); } } } @@ -3081,8 +3358,7 @@ int WriteEngineWrapper::insertColumnRec_SYS(const TxnID& txnid, { RETURN_ON_ERROR(AddLBIDtoList(txnid, newColStructList[i], - curFbo, - dummyCPInfo)); + curFbo)); } } } @@ -3210,6 +3486,8 @@ int WriteEngineWrapper::insertColumnRec_Single(const TxnID& txnid, StopWatch timer; #endif + m_opType = INSERT; + // debug information for testing if (isDebug(DEBUG_2)) { @@ -3308,7 +3586,7 @@ int WriteEngineWrapper::insertColumnRec_Single(const TxnID& txnid, rc = colOp->allocRowId(txnid, bUseStartExtent, curCol, (uint64_t)totalRow, rowIdArray, hwm, newExtent, rowsLeft, newHwm, newFile, newColStructList, newDctnryStructList, - dbRootExtentTrackers, false, false, 0); + dbRootExtentTrackers, false, false, 0, false, NULL); //-------------------------------------------------------------------------- // Handle case where we ran out of disk space allocating a new extent. @@ -3400,11 +3678,11 @@ int WriteEngineWrapper::insertColumnRec_Single(const TxnID& txnid, //-------------------------------------------------------------------------- // DMC-SHARED_NOTHING_NOTE: Is it safe to assume only part0 seg0 is abbreviated? if ((colStructList[colId].fColPartition == 0) && - (colStructList[colId].fColSegment == 0) && + (colStructList[colId].fColSegment == 0) && ((totalRow - rowsLeft) > 0) && (rowIdArray[totalRow - rowsLeft - 1] >= (RID)INITIAL_EXTENT_ROWS_TO_DISK)) { - for (unsigned k=0; kisNull) { - RETURN_ON_ERROR(tokenize( + RETURN_ON_ERROR_REPORT(tokenize( txnid, dctnryStructList[i], *dctCol_iter, true)); // @bug 5572 HDFS tmp file token = dctCol_iter->token; @@ -4264,9 +4547,19 @@ int WriteEngineWrapper::updateColumnRec(const TxnID& txnid, rid_iter = ridLists[extent].begin(); RID aRid = *rid_iter; + ExtCPInfoList currentExtentRanges; + for (const auto& colStruct : colStructList) + { + currentExtentRanges.push_back(ExtCPInfo(colStruct.colDataType, colStruct.colWidth)); // temporary for each extent. + } + std::vector currentExtentRangesPtrs(colStructList.size(), NULL); // pointers for each extent. + for (unsigned j = 0; j < colStructList.size(); j++) { colOp = m_colOp[op(colStructList[j].fCompressionType)]; + ExtCPInfo* cpInfoP = &(currentExtentRanges[j]); + cpInfoP = getCPInfoToUpdateForUpdatableType(colStructList[j], cpInfoP); + currentExtentRangesPtrs[j] = cpInfoP; if (colStructList[j].tokenFlag) continue; @@ -4278,10 +4571,9 @@ int WriteEngineWrapper::updateColumnRec(const TxnID& txnid, { if (curFbo != lastFbo) { - RETURN_ON_ERROR(AddLBIDtoList(txnid, + RETURN_ON_ERROR_REPORT(AddLBIDtoList(txnid, colStructList[j], - curFbo, - dummyCPInfo)); + curFbo, cpInfoP)); } } } @@ -4289,20 +4581,40 @@ int WriteEngineWrapper::updateColumnRec(const TxnID& txnid, //#ifdef PROFILE //timer.start("markExtentsInvalid"); //#endif - markTxnExtentsAsInvalid(txnid); if (m_opType != DELETE) m_opType = UPDATE; - rc = writeColumnRec(txnid, cscColTypeList, colStructList, colValueList, colOldValueList, - ridLists[extent], tableOid, true, ridLists[extent].size()); + rc = writeColumnRecUpdate(txnid, cscColTypeList, colStructList, colValueList, colOldValueList, + ridLists[extent], tableOid, true, ridLists[extent].size(), ¤tExtentRangesPtrs); - m_opType = NOOP; +// m_opType = NOOP; // XXX: WHY WAS IT HERE???!!! if (rc != NO_ERROR) break; - } + // copy updated ranges into bulk update vector. + for(auto cpInfoPtr : currentExtentRangesPtrs) + { + if (cpInfoPtr) + { + cpInfoPtr->fCPInfo.seqNum ++; + infosToUpdate.push_back(*cpInfoPtr); + } + } + } + markTxnExtentsAsInvalid(txnid); + if (rc == NO_ERROR) + { + ExtCPInfoList infosToDrop = infosToUpdate; + for (auto& cpInfo : infosToDrop) + { + cpInfo.fCPInfo.seqNum = SEQNUM_MARK_INVALID_SET_RANGE; + } + rc = BRMWrapper::getInstance()->setExtentsMaxMin(infosToDrop); + setInvalidCPInfosSpecialMarks(infosToUpdate); + rc = BRMWrapper::getInstance()->setExtentsMaxMin(infosToUpdate); + } return rc; } @@ -4320,11 +4632,24 @@ int WriteEngineWrapper::updateColumnRecs(const TxnID& txnid, int curFbo = 0, curBio, lastFbo = -1; RID aRid = ridLists[0]; int rc = 0; + ExtCPInfoList infosToUpdate; + for (const auto& colStruct : colExtentsStruct) + { + infosToUpdate.push_back(ExtCPInfo(colStruct.colDataType, colStruct.colWidth)); + } + ExtCPInfoList bulkUpdateInfos; + std::vector pointersToInfos; // pointersToInfos[i] points to infosToUpdate[i] and may be NULL. + + m_opType = UPDATE; for (unsigned j = 0; j < colExtentsStruct.size(); j++) { colOp = m_colOp[op(colExtentsStruct[j].fCompressionType)]; + ExtCPInfo* cpInfoP = &(infosToUpdate[j]); + cpInfoP = getCPInfoToUpdateForUpdatableType(colExtentsStruct[j], cpInfoP); + pointersToInfos.push_back(cpInfoP); + if (colExtentsStruct[j].tokenFlag) continue; @@ -4337,8 +4662,7 @@ int WriteEngineWrapper::updateColumnRecs(const TxnID& txnid, { RETURN_ON_ERROR(AddLBIDtoList(txnid, colExtentsStruct[j], - curFbo, - dummyCPInfo)); + curFbo, cpInfoP)); } } } @@ -4348,7 +4672,39 @@ int WriteEngineWrapper::updateColumnRecs(const TxnID& txnid, if (m_opType != DELETE) m_opType = UPDATE; - rc = writeColumnRecords(txnid, cscColTypeList, colExtentsStruct, colValueList, ridLists, tableOid); + for (auto cpInfoP : pointersToInfos) + { + if (cpInfoP) + { + auto tmp = *cpInfoP; + tmp.fCPInfo.seqNum = SEQNUM_MARK_INVALID_SET_RANGE; + bulkUpdateInfos.push_back(tmp); + } + } + if (!bulkUpdateInfos.empty()) + { + rc = BRMWrapper::getInstance()->setExtentsMaxMin(bulkUpdateInfos); + } + + rc = writeColumnRecords(txnid, cscColTypeList, colExtentsStruct, colValueList, ridLists, tableOid, true, &pointersToInfos); + + if (rc == NO_ERROR) + { + bulkUpdateInfos.clear(); + for (auto cpInfoP : pointersToInfos) + { + if (cpInfoP) + { + cpInfoP->fCPInfo.seqNum ++; + bulkUpdateInfos.push_back(*cpInfoP); + } + } + if (!bulkUpdateInfos.empty()) + { + setInvalidCPInfosSpecialMarks(bulkUpdateInfos); + rc = BRMWrapper::getInstance()->setExtentsMaxMin(bulkUpdateInfos); + } + } m_opType = NOOP; return rc; } @@ -4357,11 +4713,12 @@ int WriteEngineWrapper::writeColumnRecords(const TxnID& txnid, const CSCTypesList& cscColTypeList, vector& colStructList, ColValueList& colValueList, - const RIDList& ridLists, const int32_t tableOid, bool versioning) + const RIDList& ridLists, const int32_t tableOid, bool versioning, std::vector* cpInfos) { bool bExcp; int rc = 0; void* valArray = NULL; + void* oldValArray = NULL; Column curCol; ColStruct curColStruct; CalpontSystemCatalog::ColType curColType; @@ -4377,7 +4734,14 @@ int WriteEngineWrapper::writeColumnRecords(const TxnID& txnid, for (i = 0; i < totalColumn; i++) { + ExtCPInfo* cpInfo = NULL; + if (cpInfos) + { + cpInfo = (*cpInfos)[i]; + } valArray = NULL; + oldValArray = NULL; + curColStruct = colStructList[i]; curColType = cscColTypeList[i]; curTupleList = colValueList[i]; @@ -4444,6 +4808,11 @@ int WriteEngineWrapper::writeColumnRecords(const TxnID& txnid, allocateValArray(valArray, totalRow, curColStruct.colType, curColStruct.colWidth); + if (m_opType != INSERT && cpInfo) + { + allocateValArray(oldValArray, totalRow, curColStruct.colType, curColStruct.colWidth); + } + // convert values to valArray bExcp = false; @@ -4465,12 +4834,14 @@ int WriteEngineWrapper::writeColumnRecords(const TxnID& txnid, #ifdef PROFILE timer.start("writeRow "); #endif - rc = colOp->writeRowsValues(curCol, totalRow, ridLists, valArray); + rc = colOp->writeRowsValues(curCol, totalRow, ridLists, valArray, oldValArray); #ifdef PROFILE timer.stop("writeRow "); #endif colOp->clearColumn(curCol); + updateMaxMinRange(totalRow, totalRow, cscColTypeList[i], curColStruct.colType, valArray, oldValArray, cpInfo, false); + if (curColStruct.fCompressionType == 0) { std::vector files; @@ -4490,6 +4861,11 @@ int WriteEngineWrapper::writeColumnRecords(const TxnID& txnid, if (valArray != NULL) free(valArray); + if (oldValArray != NULL) + { + free(oldValArray); + } + // check error if (rc != NO_ERROR) break; @@ -4525,11 +4901,13 @@ int WriteEngineWrapper::writeColumnRec(const TxnID& txnid, ColValueList& newColValueList, const int32_t tableOid, bool useTmpSuffix, - bool versioning) + bool versioning, + ColSplitMaxMinInfoList* maxMins) { bool bExcp; int rc = 0; void* valArray; + void* oldValArray; string segFile; Column curCol; ColTupleList oldTupleList; @@ -4563,6 +4941,7 @@ int WriteEngineWrapper::writeColumnRec(const TxnID& txnid, { //Write the first batch valArray = NULL; + oldValArray = NULL; RID* firstPart = rowIdArray; ColumnOp* colOp = m_colOp[op(colStructList[i].fCompressionType)]; @@ -4627,6 +5006,19 @@ int WriteEngineWrapper::writeColumnRec(const TxnID& txnid, // have to init the size here allocateValArray(valArray, totalRow1, colStructList[i].colType, colStructList[i].colWidth); + ExtCPInfo* cpInfo = getCPInfoToUpdateForUpdatableType(colStructList[i], + maxMins ? + ((*maxMins)[i]).fSplitMaxMinInfoPtrs[0] : NULL); + + if (m_opType != INSERT && cpInfo != NULL) // we allocate space for old values only when we need them. + { + allocateValArray(oldValArray, totalRow1, colStructList[i].colType, colStructList[i].colWidth); + } + else + { + oldValArray = NULL; + } + // convert values to valArray // WIP Is m_opType ever set to DELETE? if (m_opType != DELETE) @@ -4657,7 +5049,7 @@ int WriteEngineWrapper::writeColumnRec(const TxnID& txnid, #ifdef PROFILE timer.start("writeRow "); #endif - rc = colOp->writeRow(curCol, totalRow1, firstPart, valArray); + rc = colOp->writeRow(curCol, totalRow1, firstPart, valArray, oldValArray); #ifdef PROFILE timer.stop("writeRow "); #endif @@ -4667,7 +5059,7 @@ int WriteEngineWrapper::writeColumnRec(const TxnID& txnid, #ifdef PROFILE timer.start("writeRow "); #endif - rc = colOp->writeRow(curCol, totalRow1, rowIdArray, valArray, true); + rc = colOp->writeRow(curCol, totalRow1, rowIdArray, valArray, oldValArray, true); #ifdef PROFILE timer.stop("writeRow "); #endif @@ -4675,12 +5067,17 @@ int WriteEngineWrapper::writeColumnRec(const TxnID& txnid, colOp->clearColumn(curCol); + updateMaxMinRange(totalRow1, totalRow1, cscColTypeList[i], colStructList[i].colType, valArray, oldValArray, cpInfo, rowIdArray[0] == 0 && m_opType == INSERT); + if (versioning) BRMWrapper::getInstance()->writeVBEnd(txnid, rangeList); if (valArray != NULL) free(valArray); + if (oldValArray != NULL) + free(oldValArray); + // check error if (rc != NO_ERROR) break; @@ -4688,6 +5085,7 @@ int WriteEngineWrapper::writeColumnRec(const TxnID& txnid, //Process the second batch valArray = NULL; + oldValArray = NULL; ColumnOp* colOp = m_colOp[op(newColStructList[i].fCompressionType)]; @@ -4750,8 +5148,20 @@ int WriteEngineWrapper::writeColumnRec(const TxnID& txnid, } } + ExtCPInfo* cpInfo = getCPInfoToUpdateForUpdatableType(newColStructList[i], + maxMins ? + ((*maxMins)[i]).fSplitMaxMinInfoPtrs[1] : NULL); allocateValArray(valArray, totalRow2, newColStructList[i].colType, newColStructList[i].colWidth); + if (m_opType != INSERT && cpInfo != NULL) // we allocate space for old values only when we need them. + { + allocateValArray(oldValArray, totalRow1, colStructList[i].colType, colStructList[i].colWidth); + } + else + { + oldValArray = NULL; + } + // convert values to valArray if (m_opType != DELETE) { @@ -4777,7 +5187,7 @@ int WriteEngineWrapper::writeColumnRec(const TxnID& txnid, #ifdef PROFILE timer.start("writeRow "); #endif - rc = colOp->writeRow(curCol, totalRow2, secondPart, valArray); + rc = colOp->writeRow(curCol, totalRow2, secondPart, valArray, oldValArray); // XXX: here we use secondPart array and just below we use rowIdArray. WHY??? #ifdef PROFILE timer.stop("writeRow "); #endif @@ -4787,7 +5197,7 @@ int WriteEngineWrapper::writeColumnRec(const TxnID& txnid, #ifdef PROFILE timer.start("writeRow "); #endif - rc = colOp->writeRow(curCol, totalRow2, rowIdArray, valArray, true); + rc = colOp->writeRow(curCol, totalRow2, rowIdArray, valArray, oldValArray, true); // XXX: BUG: here we use rowIdArray and just above we use secondPart array. WHY??? #ifdef PROFILE timer.stop("writeRow "); #endif @@ -4796,6 +5206,8 @@ int WriteEngineWrapper::writeColumnRec(const TxnID& txnid, colOp->clearColumn(curCol); + updateMaxMinRange(totalRow2, totalRow2, cscColTypeList[i], newColStructList[i].colType, valArray, oldValArray, cpInfo, secondPart[0] == 0 && m_opType == INSERT); + if (versioning) BRMWrapper::getInstance()->writeVBEnd(txnid, rangeList); @@ -4809,9 +5221,14 @@ int WriteEngineWrapper::writeColumnRec(const TxnID& txnid, else { valArray = NULL; + oldValArray = NULL; ColumnOp* colOp = m_colOp[op(colStructList[i].fCompressionType)]; + ExtCPInfo* cpInfo = getCPInfoToUpdateForUpdatableType(colStructList[i], + maxMins ? + ((*maxMins)[i]).fSplitMaxMinInfoPtrs[0] : NULL); + // set params colOp->initColumn(curCol); colOp->setColParam(curCol, 0, colStructList[i].colWidth, @@ -4871,6 +5288,15 @@ int WriteEngineWrapper::writeColumnRec(const TxnID& txnid, allocateValArray(valArray, totalRow1, colStructList[i].colType, colStructList[i].colWidth); + if (m_opType != INSERT && cpInfo != NULL) // we allocate space for old values only when we need them. + { + allocateValArray(oldValArray, totalRow1, colStructList[i].colType, colStructList[i].colWidth); + } + else + { + oldValArray = NULL; + } + // convert values to valArray if (m_opType != DELETE) { @@ -4878,7 +5304,7 @@ int WriteEngineWrapper::writeColumnRec(const TxnID& txnid, try { - convertValArray(totalRow1, cscColTypeList[i], colStructList[i].colType, colValueList[i], valArray); + convertValArray(totalRow1, cscColTypeList[i], colStructList[i].colType, colValueList[i], valArray, true); } catch (...) { @@ -4896,7 +5322,7 @@ int WriteEngineWrapper::writeColumnRec(const TxnID& txnid, #ifdef PROFILE timer.start("writeRow "); #endif - rc = colOp->writeRow(curCol, totalRow1, rowIdArray, valArray); + rc = colOp->writeRow(curCol, totalRow1, rowIdArray, valArray, oldValArray); #ifdef PROFILE timer.stop("writeRow "); #endif @@ -4906,7 +5332,7 @@ int WriteEngineWrapper::writeColumnRec(const TxnID& txnid, #ifdef PROFILE timer.start("writeRow "); #endif - rc = colOp->writeRow(curCol, totalRow1, rowIdArray, valArray, true); + rc = colOp->writeRow(curCol, totalRow1, rowIdArray, valArray, oldValArray, true); #ifdef PROFILE timer.stop("writeRow "); #endif @@ -4914,12 +5340,17 @@ int WriteEngineWrapper::writeColumnRec(const TxnID& txnid, colOp->clearColumn(curCol); + updateMaxMinRange(totalRow1, totalRow1, cscColTypeList[i], colStructList[i].colType, valArray, oldValArray, cpInfo, rowIdArray[0] == 0 && m_opType == INSERT); + if (versioning) BRMWrapper::getInstance()->writeVBEnd(txnid, rangeList); if (valArray != NULL) free(valArray); + if (oldValArray != NULL) + free(oldValArray); + // check error if (rc != NO_ERROR) break; @@ -5279,7 +5710,7 @@ int WriteEngineWrapper::writeColumnRecBinary(const TxnID& txnid, return rc; } -int WriteEngineWrapper::writeColumnRec(const TxnID& txnid, +int WriteEngineWrapper::writeColumnRecUpdate(const TxnID& txnid, const CSCTypesList& cscColTypeList, const ColStructList& colStructList, const ColValueList& colValueList, @@ -5287,11 +5718,13 @@ int WriteEngineWrapper::writeColumnRec(const TxnID& txnid, const RIDList& ridList, const int32_t tableOid, bool convertStructFlag, - ColTupleList::size_type nRows) + ColTupleList::size_type nRows, + std::vector* cpInfos) { bool bExcp; int rc = 0; void* valArray = NULL; + void* oldValArray = NULL; Column curCol; ColStruct curColStruct; ColTupleList curTupleList, oldTupleList; @@ -5347,6 +5780,7 @@ int WriteEngineWrapper::writeColumnRec(const TxnID& txnid, for (i = 0; i < totalColumn; i++) { valArray = NULL; + oldValArray = NULL; curColStruct = colStructList[i]; curTupleList = colValueList[i]; //same value for all rows ColumnOp* colOp = m_colOp[op(curColStruct.fCompressionType)]; @@ -5466,6 +5900,14 @@ int WriteEngineWrapper::writeColumnRec(const TxnID& txnid, allocateValArray(valArray, 1, curColStruct.colType, curColStruct.colWidth); + ExtCPInfo* cpInfo; + cpInfo = cpInfos ? ((*cpInfos)[i]) : NULL; + + if (cpInfo) + { + allocateValArray(oldValArray, totalRow, curColStruct.colType, curColStruct.colWidth); + } + // convert values to valArray if (m_opType != DELETE) { @@ -5493,7 +5935,7 @@ int WriteEngineWrapper::writeColumnRec(const TxnID& txnid, #ifdef PROFILE timer.start("writeRow "); #endif - rc = colOp->writeRows(curCol, totalRow, ridList, valArray); + rc = colOp->writeRows(curCol, totalRow, ridList, valArray, oldValArray); #ifdef PROFILE timer.stop("writeRow "); #endif @@ -5503,18 +5945,28 @@ int WriteEngineWrapper::writeColumnRec(const TxnID& txnid, #ifdef PROFILE timer.start("writeRows "); #endif - rc = colOp->writeRows(curCol, totalRow, ridList, valArray, 0, true); + rc = colOp->writeRows(curCol, totalRow, ridList, valArray, oldValArray, true); #ifdef PROFILE timer.stop("writeRows "); #endif } + updateMaxMinRange(1, totalRow, cscColTypeList[i], curColStruct.colType, m_opType == DELETE ? NULL : valArray, oldValArray, cpInfo, false); //timer.start("Delete:closefile"); colOp->clearColumn(curCol); //timer.stop("Delete:closefile"); if (valArray != NULL) + { free(valArray); + valArray = NULL; + } + + if (oldValArray != NULL) + { + free(oldValArray); + oldValArray = NULL; + } // check error if (rc != NO_ERROR) @@ -5999,6 +6451,8 @@ int WriteEngineWrapper::updateNextValue(const TxnID txnId, const OID& columnoid, colType.colDataType = colStruct.colDataType = CalpontSystemCatalog::UBIGINT; colStruct.fColDbRoot = dbRoot; + m_opType = UPDATE; + if (idbdatafile::IDBPolicy::useHdfs()) colStruct.fCompressionType = 2; @@ -6119,6 +6573,43 @@ void WriteEngineWrapper::AddDictToList(const TxnID txnid, } +// Get CPInfo for given starting LBID and column description structure. +int WriteEngineWrapper::GetLBIDRange(const BRM::LBID_t startingLBID, const ColStruct& colStruct, ExtCPInfo& cpInfo) +{ + int rtn; + BRM::CPMaxMin maxMin; + rtn = BRMWrapper::getInstance()->getExtentCPMaxMin(startingLBID, maxMin); + bool isBinary = cpInfo.isBinaryColumn(); + maxMin.isBinaryColumn = isBinary; + cpInfo.fCPInfo.firstLbid = startingLBID; + if (rtn) + { + cpInfo.toInvalid(); + return rtn; + } + // if we are provided with CPInfo pointer to update, we record current range there. + // please note that we may fail here for unknown extents - e.g., newly allocated ones. + // for these we mark CPInfo as invalid (above) and proceed as usual. + // XXX With this logic we may end with invalid ranges for extents that were + // allocated and recorded, yet not in our copy of extentmap. + // As we update only part of that extent, the recorded range will be for + // that part of the extent. + // It should be investigated whether such situation is possible. + // XXX Please note that most if not all calls to AddLBIDToList are enclosed into + // RETURN_ON_ERROR() macro. + // If we have failed to obtain information above we will abort execution of the function + // that called us. + // This is potential source of bugs. + cpInfo.fCPInfo.bigMax = maxMin.bigMax; + cpInfo.fCPInfo.bigMin = maxMin.bigMin; + cpInfo.fCPInfo.max = maxMin.max; + cpInfo.fCPInfo.min = maxMin.min; + cpInfo.fCPInfo.seqNum = maxMin.seqNum; + cpInfo.fCPInfo.isBinaryColumn = maxMin.isBinaryColumn; + return rtn; +} + + /*********************************************************** * DESCRIPTION: * Add an lbid to a list of lbids for sending to markExtentsInvalid. @@ -6135,9 +6626,9 @@ void WriteEngineWrapper::AddDictToList(const TxnID txnid, * RETURN: 0 => OK. -1 => error ***********************************************************/ int WriteEngineWrapper::AddLBIDtoList(const TxnID txnid, - const ColStruct& colStruct, + const ColStruct& colStruct, const int fbo, - const BRM::CPInfo& cpInfo) + ExtCPInfo* cpInfo) { int rtn = 0; @@ -6168,7 +6659,15 @@ int WriteEngineWrapper::AddLBIDtoList(const TxnID txnid, if (rtn != 0) return -1; - spTxnLBIDRec->AddLBID(startingLBID, colStruct.colDataType); + // if we are given the cpInfo (column's ranges can be traced), we should update it. + if (cpInfo) + { + rtn = GetLBIDRange(startingLBID, colStruct, *cpInfo); + } + else + { + spTxnLBIDRec->AddLBID(startingLBID, colStruct.colDataType); + } return rtn; } diff --git a/writeengine/wrapper/writeengine.h b/writeengine/wrapper/writeengine.h index 446aec6a6..cdc7d472d 100644 --- a/writeengine/wrapper/writeengine.h +++ b/writeengine/wrapper/writeengine.h @@ -83,7 +83,7 @@ struct TxnLBIDRec if ( m_LBIDSet.insert(lbid).second) { m_LBIDs.push_back(lbid); - m_ColDataTypes.push_back(colDataType); + m_ColDataTypes.push_back(colDataType); } } }; @@ -91,6 +91,20 @@ struct TxnLBIDRec typedef boost::shared_ptr SP_TxnLBIDRec_t; typedef std::set dictLBIDRec_t; +/** @brief Range information for 1 or 2 extents changed by DML operation. */ +struct ColSplitMaxMinInfo { + ExtCPInfo fSplitMaxMinInfo[2]; /** @brief internal to write engine: min/max ranges for data in one and, possible, second extent. */ + ExtCPInfo* fSplitMaxMinInfoPtrs[2]; /** @brief pointers to CPInfos in fSplitMaxMinInfo above */ + ColSplitMaxMinInfo(execplan::CalpontSystemCatalog::ColDataType colDataType, int colWidth) + : fSplitMaxMinInfo { ExtCPInfo(colDataType, colWidth), ExtCPInfo(colDataType, colWidth) } + { + fSplitMaxMinInfoPtrs[0] = fSplitMaxMinInfoPtrs[1] = NULL; // disable by default. + } +}; + +typedef std::vector ColSplitMaxMinInfoList; + + /** Class WriteEngineWrapper */ class WriteEngineWrapper : public WEObj { @@ -166,6 +180,15 @@ public: const ColType colType, ColTupleList& curTupleList, void* valArray, bool bFromList = true) ; + /** + * @brief Updates range information given old range information, old values, new values and column information. + */ + EXPORT void updateMaxMinRange(const size_t totalNewRow, const size_t totalOldRow, + const execplan::CalpontSystemCatalog::ColType& cscColType, + const ColType colType, + const void* valArray, const void* oldValArray, + ExtCPInfo* maxMin, bool canStartWithInvalidRange); + /** * @brief Create a column, include object ids for column data and bitmap files @@ -705,7 +728,8 @@ private: ColValueList& colValueList, RID* rowIdArray, const ColStructList& newColStructList, ColValueList& newColValueList, const int32_t tableOid, - bool useTmpSuffix, bool versioning = true); + bool useTmpSuffix, bool versioning = true, + ColSplitMaxMinInfoList* maxMins = NULL); int writeColumnRecBinary(const TxnID& txnid, const ColStructList& colStructList, std::vector& colValueList, @@ -715,18 +739,18 @@ private: bool useTmpSuffix, bool versioning = true); //@Bug 1886,2870 pass the address of ridList vector - int writeColumnRec(const TxnID& txnid, + int writeColumnRecUpdate(const TxnID& txnid, const CSCTypesList& cscColTypeList, const ColStructList& colStructList, const ColValueList& colValueList, std::vector& colOldValueList, const RIDList& ridList, const int32_t tableOid, - bool convertStructFlag = true, ColTupleList::size_type nRows = 0); + bool convertStructFlag = true, ColTupleList::size_type nRows = 0, std::vector* cpInfos = NULL); //For update column from column to use int writeColumnRecords(const TxnID& txnid, const CSCTypesList& cscColTypeList, std::vector& colStructList, ColValueList& colValueList, const RIDList& ridLists, - const int32_t tableOid, bool versioning = true); + const int32_t tableOid, bool versioning = true, std::vector* cpInfos = NULL); /** * @brief util method to convert rowid to a column file @@ -739,18 +763,24 @@ private: void AddDictToList(const TxnID txnid, std::vector& lbids); void RemoveTxnFromDictMap(const TxnID txnid); - // Bug 4312: We use a hash set to hold the set of starting LBIDS for a given + // Bug 4312: We use a hash map to hold the set of starting LBIDS for a given // txn so that we don't waste time marking the same extent as invalid. This // list should be trimmed if it gets too big. int AddLBIDtoList(const TxnID txnid, const ColStruct& colStruct, const int fbo, - const BRM::CPInfo& cpInfo // there is dummy value for you to use - ); + ExtCPInfo* cpInfo = NULL // provide CPInfo pointer if you want max/min updated. + ); + + // Get CPInfo for given starting LBID and column description structure. + int GetLBIDRange(const BRM::LBID_t startingLBID, const ColStruct& colStruct, ExtCPInfo& cpInfo); // mark extents of the transaction as invalid. erase transaction from txn->lbidsrec map if requested. int markTxnExtentsAsInvalid(const TxnID txnid, bool erase = false); + // write LBID's new ranges. + int setExtentsNewMaxMins(const ColSplitMaxMinInfoList& maxMins, bool haveSplit); + int RemoveTxnFromLBIDMap(const TxnID txnid); int op(int compressionType)