query-optimization

I have been reading in many SQL books and articles that selectivity is an important factor in creating index. If a column has low selectivity, an index seek does more harm that good. But none of the articles explain why. Can anybody explain why it is so, or provide a link to a relevant article? From SimpleTalk article by Robert Sheldon: 14 SQL Server Indexing Questions You Were Too Shy To Ask The ratio of unique values within a key column is referred to as index selectivity. The more unique the values, the higher the selectivity, which means that a unique index has the highest possible

I often see people answer MySQL questions with queries like this: SELECT DAY(date), other columns FROM table GROUP BY DAY(date); SELECT somecolumn, COUNT(*) FROM table HAVING COUNT(*) > 1; I always like to give the column an alias and refer to that in the GROUP BY or HAVING clause, e.g. SELECT DAY(date) AS day, other columns FROM table GROUP BY day; SELECT somecolumn, COUNT(*) AS c FROM table HAVING c > 1; Is MySQL smart enough to notice that the expressions in the later clauses are the same as in SELECT , and only do it once? I'm not sure how to test this -- EXPLAIN doesn't show any

I have a MySQL query (Ubu 10.04,Innodb, Core i7, 16Gb RAM, SSD drives, MySQL params optimized): SELECT COUNT(DISTINCT subscriberid) FROM em_link_data WHERE linkid in (SELECT l.id FROM em_link l WHERE l.campaignid = '2900' AND l.link != 'open') The table em_link_data has about 7million rows, em_link has a few thousand. This query will take about 18 seconds to complete. However, if I substitute the results of the subquery and do this: SELECT COUNT(DISTINCT subscriberid) FROM em_link_data WHERE linkid in (24899,24900,24901,24902); then the query will run in less than 1 millisecond. The subquery

I'm trying to get an rough (order-of-magnitude) estimate of how long time the following query could take: mysql> EXPLAIN SELECT t1.col1, t1_col4 FROM t1 LEFT JOIN t2 ON t1.col1=t2.col1 WHERE col2=0 AND col3 IS NULL; +----+-------------+--------------------+------+---------------+------------+---------+-----------------------------+---------+--------------------------+ | id | select_type | table | type | possible_keys | key | key_len | ref | rows | Extra | +----+-------------+--------------------+------+---------------+------------+---------+-----------------------------+---------+-------------

Does a user stored procedure with the prefix of SP (not SP_) have poorer performance by looking in the Master DB (similar to user SP named SP_) or does it look in the DB where the stored procedure exists because it lack an underscore? Martin Smith The reserved prefix that exhibits this behaviour is sp_ . Not sp . A stored procedure called spAddUser will be resolved in the normal way without looking for a matching object in master . The relevant quote in books online is Avoid the use of the sp_ prefix when naming procedures. This prefix is used by SQL Server to designate system procedures.

In SQLSERVER 2005, I'm using table-valued function as a convenient way to perform arbitrary aggregation on subset data from large table (passing date range or such parameters). I'm using theses inside larger queries as joined computations and I'm wondering if the query plan optimizer work well with them in every condition or if I'm better to unnest such computation in my larger queries. Does query plan optimizer unnest table-valued functions if it make sense? If it doesn't, what do you recommend to avoid code duplication that would occur by manually unnesting them? If it does, how do you

This query is very simple, all I want to do, is get all the articles in given category ordered by last_updated field: SELECT `articles`.* FROM `articles`, `articles_to_categories` WHERE `articles`.`id` = `articles_to_categories`.`article_id` AND `articles_to_categories`.`category_id` = 1 ORDER BY `articles`.`last_updated` DESC LIMIT 0, 20; But it runs very slow. Here is what EXPLAIN said: select_type table type possible_keys key key_len ref rows Extra ------------------------------------------------------------------------------------------------------------------------------------------------

I have a stored procedure that takes 5 input parameters. The procedure is a bit complicated and takes around 2 minutes to execute. I am in process of optimizing query. So, my question is, does it always help to assign input parameters to local variables and then use local variables in the procedure? If so, how does it help? I will not try and explain the full details of parameter sniffing, but in short, no it does not always help (and it can hinder). Imagine a table (T) with a primary key and an indexed Date column (A), in the table there are 1,000 rows, 400 have the same value of A (lets say