From 35fd6415062743163b8a0e81e7f6a515c0f2bc93 Mon Sep 17 00:00:00 2001 From: unknown Date: Sun, 31 Jul 2005 21:33:46 +0200 Subject: [PATCH 1/2] Fix for bug#12021 --- mysql-test/r/ndb_condition_pushdown.result | 2 +- mysql-test/t/disabled.def | 2 +- sql/ha_ndbcluster.cc | 10 ++++++---- 3 files changed, 8 insertions(+), 6 deletions(-) diff --git a/mysql-test/r/ndb_condition_pushdown.result b/mysql-test/r/ndb_condition_pushdown.result index 14cd4666528..1c3da1b486f 100644 --- a/mysql-test/r/ndb_condition_pushdown.result +++ b/mysql-test/r/ndb_condition_pushdown.result @@ -1514,7 +1514,7 @@ select auto from t1 where '1901-01-01 01:01:01' in(date_time) order by auto; id select_type table type possible_keys key key_len ref rows Extra -1 SIMPLE t1 ALL NULL NULL NULL NULL 4 Using where with pushed condition; Using filesort +1 SIMPLE t1 ref medium_index medium_index 3 const 10 Using where with pushed condition; Using filesort select auto from t1 where "aaaa" in(string) and "aaaa" in(vstring) and diff --git a/mysql-test/t/disabled.def b/mysql-test/t/disabled.def index 7d397ff2112..60543fe55f9 100644 --- a/mysql-test/t/disabled.def +++ b/mysql-test/t/disabled.def @@ -11,4 +11,4 @@ ############################################################################## sp-goto:GOTO is currently is disabled - will be fixed in the future -ndb_condition_pushdown:Bug #12021 + diff --git a/sql/ha_ndbcluster.cc b/sql/ha_ndbcluster.cc index 9e6725178d5..76e14b3d8fe 100644 --- a/sql/ha_ndbcluster.cc +++ b/sql/ha_ndbcluster.cc @@ -6350,12 +6350,14 @@ void ndb_serialize_cond(const Item *item, void *arg) // result type if (context->expecting(Item::FIELD_ITEM) && (context->expecting_field_result(field->result_type()) || - // Date and year can be written as strings + // Date and year can be written as string or int ((type == MYSQL_TYPE_TIME || type == MYSQL_TYPE_DATE || type == MYSQL_TYPE_YEAR || type == MYSQL_TYPE_DATETIME) - ? context->expecting_field_result(STRING_RESULT) : true)) && + ? (context->expecting_field_result(STRING_RESULT) || + context->expecting_field_result(INT_RESULT)) + : true)) && // Bit fields no yet supported in scan filter type != MYSQL_TYPE_BIT) { @@ -6423,8 +6425,8 @@ void ndb_serialize_cond(const Item *item, void *arg) } else { - DBUG_PRINT("info", ("Was not expecting field of type %u", - field->result_type())); + DBUG_PRINT("info", ("Was not expecting field of type %u(%u)", + field->result_type(), type)); context->supported= FALSE; } } From 7478e9df63275395fb7c932f25b474cf229dc874 Mon Sep 17 00:00:00 2001 From: unknown Date: Mon, 1 Aug 2005 11:50:43 +0200 Subject: [PATCH 2/2] Fixed handling of NOT LIKE after Item_func::NOTLIKE_FUNC has been removed --- sql/ha_ndbcluster.cc | 47 +++++++++++++++++------- sql/ha_ndbcluster.h | 87 +++++++++++++++++++++++++++++++++----------- 2 files changed, 99 insertions(+), 35 deletions(-) diff --git a/sql/ha_ndbcluster.cc b/sql/ha_ndbcluster.cc index 86325c2fd45..922a7be9921 100644 --- a/sql/ha_ndbcluster.cc +++ b/sql/ha_ndbcluster.cc @@ -7010,7 +7010,7 @@ ha_ndbcluster::build_scan_filter_predicate(Ndb_cond * &cond, switch ((negated) ? Ndb_item::negate(cond->ndb_item->qualification.function_type) : cond->ndb_item->qualification.function_type) { - case Item_func::EQ_FUNC: + case NDB_EQ_FUNC: { if (!value || !field) break; // Save value in right format for the field type @@ -7024,7 +7024,7 @@ ha_ndbcluster::build_scan_filter_predicate(Ndb_cond * &cond, cond= cond->next->next->next; DBUG_RETURN(0); } - case Item_func::NE_FUNC: + case NDB_NE_FUNC: { if (!value || !field) break; // Save value in right format for the field type @@ -7038,7 +7038,7 @@ ha_ndbcluster::build_scan_filter_predicate(Ndb_cond * &cond, cond= cond->next->next->next; DBUG_RETURN(0); } - case Item_func::LT_FUNC: + case NDB_LT_FUNC: { if (!value || !field) break; // Save value in right format for the field type @@ -7064,7 +7064,7 @@ ha_ndbcluster::build_scan_filter_predicate(Ndb_cond * &cond, cond= cond->next->next->next; DBUG_RETURN(0); } - case Item_func::LE_FUNC: + case NDB_LE_FUNC: { if (!value || !field) break; // Save value in right format for the field type @@ -7090,7 +7090,7 @@ ha_ndbcluster::build_scan_filter_predicate(Ndb_cond * &cond, cond= cond->next->next->next; DBUG_RETURN(0); } - case Item_func::GE_FUNC: + case NDB_GE_FUNC: { if (!value || !field) break; // Save value in right format for the field type @@ -7116,7 +7116,7 @@ ha_ndbcluster::build_scan_filter_predicate(Ndb_cond * &cond, cond= cond->next->next->next; DBUG_RETURN(0); } - case Item_func::GT_FUNC: + case NDB_GT_FUNC: { if (!value || !field) break; // Save value in right format for the field type @@ -7142,7 +7142,7 @@ ha_ndbcluster::build_scan_filter_predicate(Ndb_cond * &cond, cond= cond->next->next->next; DBUG_RETURN(0); } - case Item_func::LIKE_FUNC: + case NDB_LIKE_FUNC: { if (!value || !field) break; if ((value->qualification.value_type != Item::STRING_ITEM) && @@ -7161,7 +7161,26 @@ ha_ndbcluster::build_scan_filter_predicate(Ndb_cond * &cond, cond= cond->next->next->next; DBUG_RETURN(0); } - case Item_func::ISNULL_FUNC: + case NDB_NOTLIKE_FUNC: + { + if (!value || !field) break; + if ((value->qualification.value_type != Item::STRING_ITEM) && + (value->qualification.value_type != Item::VARBIN_ITEM)) + break; + // Save value in right format for the field type + value->save_in_field(field); + DBUG_PRINT("info", ("Generating NOTLIKE filter: notlike(%d,%s,%d)", + field->get_field_no(), value->get_val(), + value->pack_length())); + if (filter->cmp(NdbScanFilter::COND_NOT_LIKE, + field->get_field_no(), + value->get_val(), + value->pack_length()) == -1) + DBUG_RETURN(1); + cond= cond->next->next->next; + DBUG_RETURN(0); + } + case NDB_ISNULL_FUNC: if (!field) break; DBUG_PRINT("info", ("Generating ISNULL filter")); @@ -7169,7 +7188,7 @@ ha_ndbcluster::build_scan_filter_predicate(Ndb_cond * &cond, DBUG_RETURN(1); cond= cond->next->next; DBUG_RETURN(0); - case Item_func::ISNOTNULL_FUNC: + case NDB_ISNOTNULL_FUNC: { if (!field) break; @@ -7206,7 +7225,7 @@ ha_ndbcluster::build_scan_filter_group(Ndb_cond* &cond, NdbScanFilter *filter) case NDB_FUNCTION: { switch (cond->ndb_item->qualification.function_type) { - case Item_func::COND_AND_FUNC: + case NDB_COND_AND_FUNC: { level++; DBUG_PRINT("info", ("Generating %s group %u", (negated)?"NAND":"AND", @@ -7218,7 +7237,7 @@ ha_ndbcluster::build_scan_filter_group(Ndb_cond* &cond, NdbScanFilter *filter) cond= cond->next; break; } - case Item_func::COND_OR_FUNC: + case NDB_COND_OR_FUNC: { level++; DBUG_PRINT("info", ("Generating %s group %u", (negated)?"NOR":"OR", @@ -7230,7 +7249,7 @@ ha_ndbcluster::build_scan_filter_group(Ndb_cond* &cond, NdbScanFilter *filter) cond= cond->next; break; } - case Item_func::NOT_FUNC: + case NDB_NOT_FUNC: { DBUG_PRINT("info", ("Generating negated query")); cond= cond->next; @@ -7273,8 +7292,8 @@ ha_ndbcluster::build_scan_filter(Ndb_cond * &cond, NdbScanFilter *filter) switch (cond->ndb_item->type) { case NDB_FUNCTION: switch (cond->ndb_item->qualification.function_type) { - case Item_func::COND_AND_FUNC: - case Item_func::COND_OR_FUNC: + case NDB_COND_AND_FUNC: + case NDB_COND_OR_FUNC: simple_cond= FALSE; break; default: diff --git a/sql/ha_ndbcluster.h b/sql/ha_ndbcluster.h index 91cfdde16fe..034bb9292e8 100644 --- a/sql/ha_ndbcluster.h +++ b/sql/ha_ndbcluster.h @@ -72,10 +72,28 @@ typedef enum ndb_item_type { NDB_END_COND = 3 // End marker for condition group } NDB_ITEM_TYPE; +typedef enum ndb_func_type { + NDB_EQ_FUNC = 0, + NDB_NE_FUNC = 1, + NDB_LT_FUNC = 2, + NDB_LE_FUNC = 3, + NDB_GT_FUNC = 4, + NDB_GE_FUNC = 5, + NDB_ISNULL_FUNC = 6, + NDB_ISNOTNULL_FUNC = 7, + NDB_LIKE_FUNC = 8, + NDB_NOTLIKE_FUNC = 9, + NDB_NOT_FUNC = 10, + NDB_UNKNOWN_FUNC = 11, + NDB_COND_AND_FUNC = 12, + NDB_COND_OR_FUNC = 13, + NDB_UNSUPPORTED_FUNC = 14 +} NDB_FUNC_TYPE; + typedef union ndb_item_qualification { Item::Type value_type; - enum_field_types field_type; // Instead of Item::FIELD_ITEM - Item_func::Functype function_type; // Instead of Item::FUNC_ITEM + enum_field_types field_type; // Instead of Item::FIELD_ITEM + NDB_FUNC_TYPE function_type; // Instead of Item::FUNC_ITEM } NDB_ITEM_QUALIFICATION; typedef struct ndb_item_field_value { @@ -91,21 +109,31 @@ typedef union ndb_item_value { struct negated_function_mapping { - Item_func::Functype pos_fun; - Item_func::Functype neg_fun; + NDB_FUNC_TYPE pos_fun; + NDB_FUNC_TYPE neg_fun; }; +/* + Define what functions can be negated in condition pushdown. + Note, these HAVE to be in the same order as in definition enum +*/ static const negated_function_mapping neg_map[]= { - {Item_func::EQ_FUNC, Item_func::NE_FUNC}, - {Item_func::NE_FUNC, Item_func::EQ_FUNC}, - {Item_func::LT_FUNC, Item_func::GE_FUNC}, - {Item_func::LE_FUNC, Item_func::GT_FUNC}, - {Item_func::GT_FUNC, Item_func::LE_FUNC}, - {Item_func::GE_FUNC, Item_func::LT_FUNC}, - {Item_func::ISNULL_FUNC, Item_func::ISNOTNULL_FUNC}, - {Item_func::ISNOTNULL_FUNC, Item_func::ISNULL_FUNC}, - {Item_func::UNKNOWN_FUNC, Item_func::NOT_FUNC} + {NDB_EQ_FUNC, NDB_NE_FUNC}, + {NDB_NE_FUNC, NDB_EQ_FUNC}, + {NDB_LT_FUNC, NDB_GE_FUNC}, + {NDB_LE_FUNC, NDB_GT_FUNC}, + {NDB_GT_FUNC, NDB_LE_FUNC}, + {NDB_GE_FUNC, NDB_LT_FUNC}, + {NDB_ISNULL_FUNC, NDB_ISNOTNULL_FUNC}, + {NDB_ISNOTNULL_FUNC, NDB_ISNULL_FUNC}, + {NDB_LIKE_FUNC, NDB_NOTLIKE_FUNC}, + {NDB_NOTLIKE_FUNC, NDB_LIKE_FUNC}, + {NDB_NOT_FUNC, NDB_UNSUPPORTED_FUNC}, + {NDB_UNKNOWN_FUNC, NDB_UNSUPPORTED_FUNC}, + {NDB_COND_AND_FUNC, NDB_UNSUPPORTED_FUNC}, + {NDB_COND_OR_FUNC, NDB_UNSUPPORTED_FUNC}, + {NDB_UNSUPPORTED_FUNC, NDB_UNSUPPORTED_FUNC} }; /* @@ -160,14 +188,14 @@ class Ndb_item { Ndb_item(Item_func::Functype func_type, const Item *item_value) : type(NDB_FUNCTION) { - qualification.function_type= func_type; + qualification.function_type= item_func_to_ndb_func(func_type); value.item= item_value; value.arg_count= ((Item_func *) item_value)->argument_count(); }; Ndb_item(Item_func::Functype func_type, uint no_args) : type(NDB_FUNCTION) { - qualification.function_type= func_type; + qualification.function_type= item_func_to_ndb_func(func_type); value.arg_count= no_args; }; ~Ndb_item() @@ -229,13 +257,30 @@ class Ndb_item { ((Item *)item)->save_in_field(field, false); }; - static Item_func::Functype negate(Item_func::Functype fun) + static NDB_FUNC_TYPE item_func_to_ndb_func(Item_func::Functype fun) { - uint i; - for (i=0; - fun != neg_map[i].pos_fun && - neg_map[i].pos_fun != Item_func::UNKNOWN_FUNC; - i++); + switch (fun) { + case (Item_func::EQ_FUNC): { return NDB_EQ_FUNC; } + case (Item_func::NE_FUNC): { return NDB_NE_FUNC; } + case (Item_func::LT_FUNC): { return NDB_LT_FUNC; } + case (Item_func::LE_FUNC): { return NDB_LE_FUNC; } + case (Item_func::GT_FUNC): { return NDB_GT_FUNC; } + case (Item_func::GE_FUNC): { return NDB_GE_FUNC; } + case (Item_func::ISNULL_FUNC): { return NDB_ISNULL_FUNC; } + case (Item_func::ISNOTNULL_FUNC): { return NDB_ISNOTNULL_FUNC; } + case (Item_func::LIKE_FUNC): { return NDB_LIKE_FUNC; } + case (Item_func::NOT_FUNC): { return NDB_NOT_FUNC; } + case (Item_func::UNKNOWN_FUNC): { return NDB_UNKNOWN_FUNC; } + case (Item_func::COND_AND_FUNC): { return NDB_COND_AND_FUNC; } + case (Item_func::COND_OR_FUNC): { return NDB_COND_OR_FUNC; } + default: { return NDB_UNSUPPORTED_FUNC; } + } + }; + + static NDB_FUNC_TYPE negate(NDB_FUNC_TYPE fun) + { + uint i= (uint) fun; + DBUG_ASSERT(fun == neg_map[i].pos_fun); return neg_map[i].neg_fun; };