I have a table and i need to recover most repeated occurrence
in the example the occurrence repeats is kills:8
I not want to get the most value, i need get the most repeated value
id | member | kills
1 | - | 9
2 | - | 8
3 | - | 4
4 | - | 8
5 | - | 7
thank you
Group by kills, then order by count of the values in a descending manner, then limit to only one row.
SELECT
kills,
COUNT(id) AS kill_count
FROM table
GROUP BY kills
ORDER BY kill_count DESC
LIMIT 1
Try this query
SELECT kills, COUNT(id) FROM TABLE_NAME GROUP BY kills HAVING COUNT(id) > 1
Juz refer the link
SELECT kills,
count(kills)
FROM TEMP
GROUP BY kills
ORDER BY count(kills) DESC LIMIT 1;
My only idea is to run a while loop that counts each value in the kills column, tallies it and then runs if statements to get the highest tally. Hope this helps.
Related
I am trying to get a certain amount of rows of which another amount of rows satisfy a specific condition.
I'll explain.
table 1:
ID | NAME
1 | Thomas
2 | Jason
3 | Oleg
4 | Matt
5 | Sheldon
6 | Jenny
table 2:
ID | ACTIVE
1 | 1
2 | 0
3 | 1
4 | 1
5 | 0
6 | 1
Query:
SELECT tbl_1.ID, tbl_1.NAME, tbl_2.ACTIVE
FROM tbl_1 JOIN tbl_2 ON
tbl_1.ID = tbl_2.ID
WHERE tbl_2.ACTIVE=1
LIMIT 5
in this example I would like to get a minimum number of 5 users, of which 3 are active.
of course the query above will not do the job right, as it limits the total rows to 5. But 3 of the rows in the result (or less if no more exist) MUST be active.
the other way I can think of getting this done, is a union, but my query is so cumbersome, long and complex.
Any ideas?
Use ORDER BY instead:
SELECT tbl_1.ID, tbl_1.NAME, tbl_2.ACTIVE
FROM tbl_1 JOIN
tbl_2
ON tbl_1.ID = tbl_2.ID
ORDER BY (tbl_2.ACTIVE = 1) DESC
LIMIT 5;
This puts the active users at the top of the list and then fills in the rest with other users.
Note: The ORDER BY clause could simply be ORDER BY tbl_2.ACTIVE DESC. I left the boolean logic so you could see the similarity to the WHERE clause.
The way to at least x results is to use the count aggregate and the keyword having
select f1, count(*) records
from yourTable
where whatever
group by f1
having count(*) > x
I have a table of urls. I need to select 1, in round robin. Hoping to display 1 per pageview OR per Visitor and show each 20 times if I have 100 pageviews OR Visitors.
Essentially: SELECT url FROM table LIMIT 1 (in rotation)
+-------+---------------------+
| id | url |
+-------+---------------------+
| 1 | http://google.com |
| 2 | http://yahoo.com |
| 3 | http://ebay.com |
| 4 | http://anything.com |
| 5 | http://other.com |
+-------+---------------------+
If I understand correctly what you mean by round-robin then you can do something along the lines of
SELECT id, url
FROM urls u CROSS JOIN
(
SELECT MIN(id) min_id, MAX(id) max_id
FROM urls
) m
WHERE id > IF(? >= max_id, 0, ?) -- last shown id goes here instead of placeholders
ORDER BY id
LIMIT 1;
Store (in session, file, another table, etc.) and pass to your query the last shown id or 0 for the initial query.
This will give you the next row or first again if you reached the last one.
This query will still work if you have gaps in ids.
Here is a SQLFiddle demo
You can do using order by rand()
SELECT * FROM table ORDER BY rand() LIMIT 1
You can use RAND() function in your ORDER BY clause:
SELECT * FROM tableName ORDER BY RAND() LIMIT 1
Is this what you want to achieve?
I was just wondering that, how to get the greatest number in the table.
I mean i have a table called: hits; in that their are 2 columns:
1. id
2. hit
and their are many ids in the table and all have more than 10 hits, now what i want to do is to get the greatest id of the greatest hit
PS: See below:
id | hit
---|----
1 | 10
2 | 15
3 | 45
4 | 9
yes you can use MAX function to use like below
Select Id,Max(hit) from yourtableName group by id having hit=Max(hit)
Select Id,
Max(Hit)
from tableName
group by id
having Max(hit)=(Select Max(Hit) from TableName)
SQL FIDDLE Demo
Wouldn't it be faster to do this:
SELECT * FROM table WHERE 1 ORDER BY hit DESC, id DESC LIMIT 1
Rather than using MAX, Especially if you have a larger table
http://www.witti.ws/blog/2011/04/06/mysqls-max-slow-5-years-later
I'm querying a table to find the most common string in a column. However, it doens't seem to be working correctly. It should be returning the value of the most common string, but is instead returning the number of times the most common string exists. The query is:
SELECT COUNT(field_review_bar_tab_2_value) AS `Rows`
FROM (field_data_field_review_bar_tab_2)
GROUP BY (field_review_bar_tab_2_value)
ORDER BY `Rows` DESC
LIMIT 1
Table structure, simplified, would be something to the effect of:
-----------------------------------
| ID | field_review_bar_tab_2_value |
|----+----------------------------- |
| 1 | Food Drinks |
| 2 | Drinks |
| 3 | Food Drinks |
| 4 | Food |
-----------------------------------
The query is recognizing that, in the example above, "Food Drinks" is the most common string in the column. But, the query is returning "2" instead of "Food Drinks". Any ideas as to why it would be making the correct query but returning the count of the result instead of the value of the string?
You need to include field_review_bar_tab_2_value in the SELECT list as well. I've switched the aggregate to COUNT(*) here, and included the grouped column in the SELECT.
SELECT
field_review_bar_tab_2_value AS the_most_common_string,
COUNT(*) AS `Rows`
FROM (field_data_field_review_bar_tab_2)
GROUP BY (field_review_bar_tab_2_value)
ORDER BY `Rows` DESC
LIMIT 1
You're selecting the count, not the value. I think you mean:
SELECT field_review_bar_tab_2_value
FROM field_data_field_review_bar_tab_2
GROUP BY field_review_bar_tab_2_value
ORDER BY COUNT(*) DESC
LIMIT 1
Since you're already grouping by the value in question, you can just do COUNT(*)...
You will need to modify your query to return the field itself. Currently the query is only returning the COUNT because that's what is indicated in your select statement. Modify it as follows:
SELECT field_review_bar_tab_2_value AS `MostCommonString`, COUNT(field_review_bar_tab_2_value) AS `Rows`
FROM (field_data_field_review_bar_tab_2)
GROUP BY (field_review_bar_tab_2_value)
ORDER BY `Rows` DESC
LIMIT 1
I am searching for records in a table as follows:
SELECT Id, Name FROM my_table WHERE Name LIKE '%prashant%' LIMIT 0, 10;
Now, I am adding LIMIT to maintain my paging. But when user searches for word 'prashant' then total records I have is 124 for 'prashant'. But as the limit applied to the query so it only fetches 10 records in my PHP script and when I am count the mysql variable in PHP code it returns total records found is 10.
So basically I want to count and Limit using a single query, by making some modification in the above query, I want the total count (124) of records. I don't want to run a separate count(*) query for just counting the total result found by the query.
Thanks.
SELECT SQL_CALC_FOUND_ROWS
Id, Name
FROM my_table
WHERE
Name LIKE '%prashant%'
LIMIT 0, 10;
# Find total rows
SELECT FOUND_ROWS();
more info
MySQL supports doing this using SQL_CALC_FOUND_ROWS as mentioned by Ionut. However, it turns out that in many cases it's actually faster to do it the old fashioned way using two statements, where one of them is a regular count(). This does however require that the counting can be done using an index scan, which won't be the case for this very query, but I thought I'd mention it anyway.
This is for others with the same need (considering it's been 3 years from the time of this question).
I had a similar issue and I didn't want to create 2 queries. So what I did was to create an additional column for the total number and moved the LIMIT and OFFSET clauses at the end:
SELECT SQL_CALC_FOUND_ROWS * FROM (
SELECT `id`, `name`
FROM `my_table`
WHERE `name` LIKE '%prashant%'
) res,
(SELECT /*CEIL(FOUND_ROWS()/10) AS 'pages',*/ FOUND_ROWS() AS 'total') tot
LIMIT 0, 10
So the result is something like
| id | name | total |
+-----+----------------+-------+
| 1 | Jason Prashant | 124 |
| 2 | Bob Prashant | 124 |
| 3 | Sam Prashant | 124 |
| 4 | etc. prashant | 124 |
and I think this solution has no disadvantage in timing because it fetches the result only once, and then uses the already calculated row count for the additional column.
In case of huge tables and selecting multiple fields (not just Id, Name as in your example) i would recommend to use 2 queries. Selecting count(0) first with all those WHERE clauses and only then build the pagination, selecting data etc.
It will work really faster on some popular eCommerce website, for example.
Don't use SQL_CALC_FOUND_ROWS and FOUND_ROWS()
there are the bugs reported
here: https://bugs.mysql.com/bug.php?id=18454
and here: https://bugs.mysql.com/bug.php?id=19553
while on small tables BENCHMARK is dependent more on other things and the resulting time your SELECT will take will be roughly the same as COUNT(0) - SQL_CALC_FOUND_ROWS still puts restraints on LIMIT and ORDER BY database optimizations so if you depend on them don't use SQL_CALC_FOUND_ROWS
on large tables the BENCHMARK difference becomes huge where a COUNT(0) might take 0.003 sec the same SQL_CALC_FOUND_ROWS might now take 20 sec
By all metrices COUNT(0) is the superior choice
COUNT(0) SYNTAX:
(SELECT COUNT(0) FROM tableNames WHERE condition) AS alias
// alias is optional but needed if you need to use the result later
So your total query would look like this
(SELECT COUNT(0) FROM my_table WHERE name LIKE '%prashant%') AS countResults;
SELECT Id, Name FROM my_table WHERE Name LIKE '%prashant%' LIMIT 0, 10;
And then just call countResults whereever you need it elsewhere...
Another advantage of using COUNT(0) is you can use it for searching both the same table as here or you can use it to search a different table...
So for instance if each person found also has 3, 2, 1, 5 diffenrent jobs respectively... you could just add a
(SELECT COUNT(0) FROM my_jobs_table WHERE name = name_row_in_jobs_table) AS jobs
inside your original SELECT like this
SELECT Id, Name (SELECT COUNT(0) FROM my_jobs_table WHERE name = name_row_in_jobs_table) AS jobs FROM my_table WHERE Name LIKE '%prashant%' LIMIT 0, 10;
Giving you:
--------------------
| id | Name | jobs |
--------------------
| 1 | Alice| 3 |
--------------------
| 2 | John | 2 |
--------------------
| 3 | Bob | 1 |
--------------------
| 4 | Jill | 5 |
--------------------
So when showing name[3] (ie. Bob) you could also show that Bob has 1 job by calling jobs[3]...