1berry/MariaDB-server
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Merge mskold@bk-internal.mysql.com:/home/bk/mysql-5.0

Browse Source 
into  mysql.com:/usr/local/home/marty/MySQL/mysql-5.0
This commit is contained in:
unknown 2005-08-01 12:05:52 +02:00
commit aa337b1d5e
4 changed files with 107 additions and 41 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
mysql-test/r/ndb_condition_pushdown.result
View File

@ -1514,7 +1514,7 @@ select auto from t1 where
'1901-01-01 01:01:01' in(date_time) '1901-01-01 01:01:01' in(date_time)
order by auto; order by auto;
id select_type table type possible_keys key key_len ref rows Extra 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 select auto from t1 where
"aaaa" in(string) and "aaaa" in(string) and
"aaaa" in(vstring) and "aaaa" in(vstring) and

2
mysql-test/t/disabled.def
View File

@ -11,4 +11,4 @@
############################################################################## ##############################################################################
sp-goto:GOTO is currently is disabled - will be fixed in the future sp-goto:GOTO is currently is disabled - will be fixed in the future
ndb_condition_pushdown:Bug #12021

57
sql/ha_ndbcluster.cc
View File

@ -6353,12 +6353,14 @@ void ndb_serialize_cond(const Item *item, void *arg)
// result type // result type
if (context->expecting(Item::FIELD_ITEM) && if (context->expecting(Item::FIELD_ITEM) &&
(context->expecting_field_result(field->result_type()) || (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_TIME ||
type == MYSQL_TYPE_DATE || type == MYSQL_TYPE_DATE ||
type == MYSQL_TYPE_YEAR || type == MYSQL_TYPE_YEAR ||
type == MYSQL_TYPE_DATETIME) 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 // Bit fields no yet supported in scan filter
type != MYSQL_TYPE_BIT) type != MYSQL_TYPE_BIT)
{ {
@ -6426,8 +6428,8 @@ void ndb_serialize_cond(const Item *item, void *arg)
} }
else else
{ {
DBUG_PRINT("info", ("Was not expecting field of type %u", DBUG_PRINT("info", ("Was not expecting field of type %u(%u)",
field->result_type())); field->result_type(), type));
context->supported= FALSE; context->supported= FALSE;
} }
} }
@ -7010,7 +7012,7 @@ ha_ndbcluster::build_scan_filter_predicate(Ndb_cond * &cond,
switch ((negated) ? switch ((negated) ?
Ndb_item::negate(cond->ndb_item->qualification.function_type) Ndb_item::negate(cond->ndb_item->qualification.function_type)
: 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; if (!value || !field) break;
// Save value in right format for the field type // Save value in right format for the field type
@ -7024,7 +7026,7 @@ ha_ndbcluster::build_scan_filter_predicate(Ndb_cond * &cond,
cond= cond->next->next->next; cond= cond->next->next->next;
DBUG_RETURN(0); DBUG_RETURN(0);
} }
case Item_func::NE_FUNC: case NDB_NE_FUNC:
{ {
if (!value || !field) break; if (!value || !field) break;
// Save value in right format for the field type // Save value in right format for the field type
@ -7038,7 +7040,7 @@ ha_ndbcluster::build_scan_filter_predicate(Ndb_cond * &cond,
cond= cond->next->next->next; cond= cond->next->next->next;
DBUG_RETURN(0); DBUG_RETURN(0);
} }
case Item_func::LT_FUNC: case NDB_LT_FUNC:
{ {
if (!value || !field) break; if (!value || !field) break;
// Save value in right format for the field type // Save value in right format for the field type
@ -7064,7 +7066,7 @@ ha_ndbcluster::build_scan_filter_predicate(Ndb_cond * &cond,
cond= cond->next->next->next; cond= cond->next->next->next;
DBUG_RETURN(0); DBUG_RETURN(0);
} }
case Item_func::LE_FUNC: case NDB_LE_FUNC:
{ {
if (!value || !field) break; if (!value || !field) break;
// Save value in right format for the field type // Save value in right format for the field type
@ -7090,7 +7092,7 @@ ha_ndbcluster::build_scan_filter_predicate(Ndb_cond * &cond,
cond= cond->next->next->next; cond= cond->next->next->next;
DBUG_RETURN(0); DBUG_RETURN(0);
} }
case Item_func::GE_FUNC: case NDB_GE_FUNC:
{ {
if (!value || !field) break; if (!value || !field) break;
// Save value in right format for the field type // Save value in right format for the field type
@ -7116,7 +7118,7 @@ ha_ndbcluster::build_scan_filter_predicate(Ndb_cond * &cond,
cond= cond->next->next->next; cond= cond->next->next->next;
DBUG_RETURN(0); DBUG_RETURN(0);
} }
case Item_func::GT_FUNC: case NDB_GT_FUNC:
{ {
if (!value || !field) break; if (!value || !field) break;
// Save value in right format for the field type // Save value in right format for the field type
@ -7142,7 +7144,7 @@ ha_ndbcluster::build_scan_filter_predicate(Ndb_cond * &cond,
cond= cond->next->next->next; cond= cond->next->next->next;
DBUG_RETURN(0); DBUG_RETURN(0);
} }
case Item_func::LIKE_FUNC: case NDB_LIKE_FUNC:
{ {
if (!value || !field) break; if (!value || !field) break;
if ((value->qualification.value_type != Item::STRING_ITEM) && if ((value->qualification.value_type != Item::STRING_ITEM) &&
@ -7161,7 +7163,26 @@ ha_ndbcluster::build_scan_filter_predicate(Ndb_cond * &cond,
cond= cond->next->next->next; cond= cond->next->next->next;
DBUG_RETURN(0); 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) if (!field)
break; break;
DBUG_PRINT("info", ("Generating ISNULL filter")); DBUG_PRINT("info", ("Generating ISNULL filter"));
@ -7169,7 +7190,7 @@ ha_ndbcluster::build_scan_filter_predicate(Ndb_cond * &cond,
DBUG_RETURN(1); DBUG_RETURN(1);
cond= cond->next->next; cond= cond->next->next;
DBUG_RETURN(0); DBUG_RETURN(0);
case Item_func::ISNOTNULL_FUNC: case NDB_ISNOTNULL_FUNC:
{ {
if (!field) if (!field)
break; break;
@ -7206,7 +7227,7 @@ ha_ndbcluster::build_scan_filter_group(Ndb_cond* &cond, NdbScanFilter *filter)
case NDB_FUNCTION: case NDB_FUNCTION:
{ {
switch (cond->ndb_item->qualification.function_type) { switch (cond->ndb_item->qualification.function_type) {
case Item_func::COND_AND_FUNC: case NDB_COND_AND_FUNC:
{ {
level++; level++;
DBUG_PRINT("info", ("Generating %s group %u", (negated)?"NAND":"AND", DBUG_PRINT("info", ("Generating %s group %u", (negated)?"NAND":"AND",
@ -7218,7 +7239,7 @@ ha_ndbcluster::build_scan_filter_group(Ndb_cond* &cond, NdbScanFilter *filter)
cond= cond->next; cond= cond->next;
break; break;
} }
case Item_func::COND_OR_FUNC: case NDB_COND_OR_FUNC:
{ {
level++; level++;
DBUG_PRINT("info", ("Generating %s group %u", (negated)?"NOR":"OR", DBUG_PRINT("info", ("Generating %s group %u", (negated)?"NOR":"OR",
@ -7230,7 +7251,7 @@ ha_ndbcluster::build_scan_filter_group(Ndb_cond* &cond, NdbScanFilter *filter)
cond= cond->next; cond= cond->next;
break; break;
} }
case Item_func::NOT_FUNC: case NDB_NOT_FUNC:
{ {
DBUG_PRINT("info", ("Generating negated query")); DBUG_PRINT("info", ("Generating negated query"));
cond= cond->next; cond= cond->next;
@ -7273,8 +7294,8 @@ ha_ndbcluster::build_scan_filter(Ndb_cond * &cond, NdbScanFilter *filter)
switch (cond->ndb_item->type) { switch (cond->ndb_item->type) {
case NDB_FUNCTION: case NDB_FUNCTION:
switch (cond->ndb_item->qualification.function_type) { switch (cond->ndb_item->qualification.function_type) {
case Item_func::COND_AND_FUNC: case NDB_COND_AND_FUNC:
case Item_func::COND_OR_FUNC: case NDB_COND_OR_FUNC:
simple_cond= FALSE; simple_cond= FALSE;
break; break;
default: default:

85
sql/ha_ndbcluster.h
View File

@ -72,10 +72,28 @@ typedef enum ndb_item_type {
NDB_END_COND = 3 // End marker for condition group NDB_END_COND = 3 // End marker for condition group
} NDB_ITEM_TYPE; } 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 { typedef union ndb_item_qualification {
Item::Type value_type; Item::Type value_type;
enum_field_types field_type; // Instead of Item::FIELD_ITEM enum_field_types field_type; // Instead of Item::FIELD_ITEM
Item_func::Functype function_type; // Instead of Item::FUNC_ITEM NDB_FUNC_TYPE function_type; // Instead of Item::FUNC_ITEM
} NDB_ITEM_QUALIFICATION; } NDB_ITEM_QUALIFICATION;
typedef struct ndb_item_field_value { typedef struct ndb_item_field_value {
@ -91,21 +109,31 @@ typedef union ndb_item_value {
struct negated_function_mapping struct negated_function_mapping
{ {
Item_func::Functype pos_fun; NDB_FUNC_TYPE pos_fun;
Item_func::Functype neg_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[]= static const negated_function_mapping neg_map[]=
{ {
{Item_func::EQ_FUNC, Item_func::NE_FUNC}, {NDB_EQ_FUNC, NDB_NE_FUNC},
{Item_func::NE_FUNC, Item_func::EQ_FUNC}, {NDB_NE_FUNC, NDB_EQ_FUNC},
{Item_func::LT_FUNC, Item_func::GE_FUNC}, {NDB_LT_FUNC, NDB_GE_FUNC},
{Item_func::LE_FUNC, Item_func::GT_FUNC}, {NDB_LE_FUNC, NDB_GT_FUNC},
{Item_func::GT_FUNC, Item_func::LE_FUNC}, {NDB_GT_FUNC, NDB_LE_FUNC},
{Item_func::GE_FUNC, Item_func::LT_FUNC}, {NDB_GE_FUNC, NDB_LT_FUNC},
{Item_func::ISNULL_FUNC, Item_func::ISNOTNULL_FUNC}, {NDB_ISNULL_FUNC, NDB_ISNOTNULL_FUNC},
{Item_func::ISNOTNULL_FUNC, Item_func::ISNULL_FUNC}, {NDB_ISNOTNULL_FUNC, NDB_ISNULL_FUNC},
{Item_func::UNKNOWN_FUNC, Item_func::NOT_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) Ndb_item(Item_func::Functype func_type, const Item *item_value)
: type(NDB_FUNCTION) : type(NDB_FUNCTION)
{ {
qualification.function_type= func_type; qualification.function_type= item_func_to_ndb_func(func_type);
value.item= item_value; value.item= item_value;
value.arg_count= ((Item_func *) item_value)->argument_count(); value.arg_count= ((Item_func *) item_value)->argument_count();
}; };
Ndb_item(Item_func::Functype func_type, uint no_args) Ndb_item(Item_func::Functype func_type, uint no_args)
: type(NDB_FUNCTION) : type(NDB_FUNCTION)
{ {
qualification.function_type= func_type; qualification.function_type= item_func_to_ndb_func(func_type);
value.arg_count= no_args; value.arg_count= no_args;
}; };
~Ndb_item() ~Ndb_item()
@ -229,13 +257,30 @@ class Ndb_item {
((Item *)item)->save_in_field(field, false); ((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; switch (fun) {
for (i=0; case (Item_func::EQ_FUNC): { return NDB_EQ_FUNC; }
fun != neg_map[i].pos_fun && case (Item_func::NE_FUNC): { return NDB_NE_FUNC; }
neg_map[i].pos_fun != Item_func::UNKNOWN_FUNC; case (Item_func::LT_FUNC): { return NDB_LT_FUNC; }
i++); 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; return neg_map[i].neg_fun;
}; };