WHERE clause searches are being done in this manner
Val #1: always = one single integer value
Val #2: IN(1 to 4 CSV integer values)
Val #3: IN(unknown number of CSV integer values, probably max of 50)
Val #4: LIKE ’string%’

I actually have not added the column/data for Val #3 yet. Just doing searches as above on (Val #1, #2, #4) are very fast. I’m worried that when I add Val #3, things will get quite slow. So I’m wondering, are there a certain number of CSV values that will make the IN() search actually slow down? I’m not worried if I only have a few in there. But if I need to have “Val #3 IN (1,2,3,4,5,6…50)” will that make index access super slow?

Thanks.

We only select a range of records in one large table to join another large table. the join fields are indexed and the selection of the records for join uses primary key.
the time for retrieving records between 1-20000, 20000-40000, … is quite stable (about 5 seconds for each range).

However, when it came to about 560000-580000 and above, the time became significant longer (more than 50 seconds). I don’t know why this happens and if any one also had this problem.

I have 500,000 user records.
Each user is going to have a score based on values from another table. (the average of 30 scores for each user)

How should I create table structure so I can do rankings for each user based on their
average score?

So rank 1 through to rank 500,000. Want to be able to view -quickly- someones rank via SQL at anytime.
Is this possible?

Any suggestion?

Thanks
Adnan

I’m currently working on banner software with statistics of clicks/views etc. I’m testing with table with ~ 10 000 000 rows generated randomly. In first table I store all events with all information IDs (browser id, platform id, country/ip interval id etc.) along with time when event happened. The most common query in such cases is to get top N results for browsers/platforms/countries etc in any time period.

The main event table definition is
CREATE TABLE IF NOT EXISTS `stats` (
`id` int(11) unsigned NOT NULL AUTO_INCREMENT,
`banner_id` int(11) unsigned NOT NULL,
`location_id` tinyint(3) unsigned NOT NULL,
`url_id` int(11) unsigned NOT NULL,
`page_id` int(11) unsigned NOT NULL,
`dateline` int(11) unsigned NOT NULL,
`ip_interval` int(11) unsigned NOT NULL,
`browser_id` tinyint(3) unsigned NOT NULL,
`platform_id` tinyint(3) unsigned NOT NULL,
PRIMARY KEY (`id`),
KEY `bannerid` (`banner_id`),
KEY `dateline` (`dateline`),
KEY `ip_interval` (`ip_interval`)
) ENGINE=MyISAM DEFAULT CHARSET=latin1 PACK_KEYS=1 ROW_FORMAT=FIXED AUTO_INCREMENT=10100001 ;

The country codes stored in different table named iplist
CREATE TABLE IF NOT EXISTS `iplist` (
`id` int(11) unsigned NOT NULL AUTO_INCREMENT,
`code` varchar(2) NOT NULL,
`code_3` varchar(3) NOT NULL,
`name` varchar(255) NOT NULL,
`start` int(11) unsigned NOT NULL,
`end` int(11) unsigned NOT NULL,
PRIMARY KEY (`id`),
KEY `code` (`code`)
) ENGINE=MyISAM DEFAULT CHARSET=latin1 AUTO_INCREMENT=91748 ;

So the query to get top 10 countries will be

SELECT iplist.code COUNT(stat.ip_interval ) AS count
FROM stats AS stat
LEFT JOIN iplist AS iplist ON (iplist.id=stat.ip_interval)
WHERE stat.dateline>=1243382400 AND dateline<1243466944
GROUP BY code
ORDER BY count DESC
LIMIT 0, 10

This query takes ~13 seconds to run (2GHZ Dual Core CPU, 2GB RAM).

EXPLAIN this query shows that it uses JOIN perfectly.

id select_type table type possible_keys key key_len ref rows Extra
1 SIMPLE stat range dateline dateline 4 NULL 277483 Using where; Using temporary; Using filesort
1 SIMPLE iplist eq_ref PRIMARY PRIMARY 4 vb38.stat.ip_interval 1

So have you any idea how this query can be optimized further or it’s normal time for such query?

I am relatively new to working with databases and have a table that is about 7 million rows. It seems to be taking forever (2+ hrs) if I need to make any changes to the table (i.e. adding columns, changing column names, etc.) Is there an easy way to make these operations go faster? Thanks!

i wanted to know your insight about my problem.

QUERY USED:
SELECT DISTINCT MachineName FROM LogDetails WHERE NOT MachineName IS NULL AND MachineName !=” ORDER BY MachineName

SETUP A:
We have a web application that uses MS SQL database. When invoking a SELECT statement in LogDetails table(having approx. 4 million rows), the execution time is more or less 30 seconds.

SPECS of SETUP A:
OS: Windows XP Prof
Memory: 512MB

SETUP B:
It was decided to use MYSql instead of MS SQL. It took approx. 2.5-3 mins to invoke the same query used in SETUP A.

SPECS of SETUP B:
OS: Red Hat Linux 4
Memory: 512MB

QUESTION:
1) Why does MS SQL performs faster when they have the same specs though with different OS?
2) I know the memory can affect the performance but why has it not affected MS SQL much compared with MYSQL?
3) Any suggestions on how to improve SETUP B?

“the good solution is to make sure your data fits in memory as good as possible”

Do you mean ensuring SELECTs return less data than the sytems’s RAM?

Question 2
Big joins are bad. But, do you have any suggestions on how to circumvent them?
I’m thinking of doing a number of queries to SELECT subsets of data into smaller TEMPORARY TABLES then doing a JOIN on them.