query-optimization

Are MySQL operations multithreaded? Specifically, on running a select, does the select (or join) algorithm spawn multiple threads to run together? Would being multi-threaded prevent being able to support a lot of concurrent users? Several background threads run in a MySQL server. Also, each database connection is served by a single thread. Parallel queries (selects using multiple threads) are not implemented in MySQL. MySQL as is can support "a lot of concurrent useres". For example Facebook started successfully with MySQL. Besides each connection has a thread, there are several management

This question is related to this one. I have table which contains power values for devices and I need to calculate power consumption for given time span and return 10 most power consuming devices. I have generated 192 devices and 7742208 measurement records (40324 for each). This is roughly how much records devices would produce in one month. For this amount of data my current query takes over 40s to execute which is too much because time span and amount of devices and measurements could be much higher. Should I try to solve this with different approach than lag() OVER PARTITION and what other

I'm testing different queries and I'm curious about how db decide using Bitmap Heap Scan and Index Scan. create index customers_email_idx on customers(email varchar_pattern_ops); As you can see there is a customers table (dellstore example) and I add an index to email column. First query is here: select * from customers where email like 'ITQ%@dell.com'; -> query with Index Scan Explain analyze query is here: QUERY PLAN --------------------------------------------------------------------------------------------------------------------------------- Index Scan using customers_email_idx on

my example is on MYSQL VERSION is 5.6.34-log Problem summary the below query takes 40 seconds , ORDER_ITEM table has 758423 records And PAYMENT table has 177272 records And submission_entry table has 2165698 records as A Whole Table count. DETAILS HERE: BELOW: I Have This Query, Refer to [1] I Have added SQL_NO_CACHE for testing repeated tests when re query. I Have Optimized indexes Refer to [2] , but no significant improvement. Find Table Structures here [3] Find explain plan used [4] [1] SELECT SQL_NO_CACHE `payment`.`id` AS id, `order_item`.`order_id` AS order_id, GROUP_CONCAT(DISTINCT

I have two tables named as: table_product table_user_ownned_auction table_product specific_product_id astatus ... (primary_key,autoinc) -------------------------------------- 1 APAST ... 2 ALIVE ... 3 ALIVE ... 4 APAST ... 5 APAST ... table_user_ownned_auction own_id specific_product_id details ---------------------------------------- 1 1 XXXX 2 5 XXXX I need to select atatus = APAST , and not in table 2. Which means, in above structure table1 has 3 APAST status (1,4,5). But in table 2 specific_product_id (1,5) only stored so i need to select specific_product_id = 4 I used this query SELECT *

i have a query like this: select * from ( select * from TableX where col1 % 2 = 0 ) subquery where col1 % 4 = 0 The actual subquery is more complicated. when i execute the subquery alone it returns maybe 200rows quickly, but when i execute the whole query, it takes too long to wait. I know sql server takes some optimization here and merge the where statement into the subquery, and produce the new execution plan which is not that efficient. Althought i can dive into the execution plan and analyze why, like index missing, statistics stale. But i surely know that, my subquery which serves as a

When using EXPLAIN QUERY PLAN in SQLite 3 it sometimes gives me output such as SEARCH TABLE staff AS s USING AUTOMATIC COVERING INDEX (is_freelancer=? AND sap=?) (~6 rows) Where does the index come from and what does it do? The table has no manually created indices on it. "Automatic" means that SQLite creates a temporary index that is used only for this query, and deleted afterwards. This happens when the cost of creating the index is estimated to be smaller than the cost of looking up records in the table without the index. (A covering index is an index that contains all the columns to be

I'm trying to write the most optimal query to find all of the documents that do not have a specific field. Is there any better way to do this than the examples I have listed below? // Get the ids of all documents missing "location" r.db("mydb").table("mytable").filter({location: null},{default: true}).pluck("id") // Get a count of all documents missing "location" r.db("mydb").table("mytable").filter({location: null},{default: true}).count() Right now, these queries take about 300-400ms on a table with ~40k documents, which seems rather slow. Furthermore, in this specific case, the "location"