query-optimization

We have a passing control system and every pass action is stored Event table in MSSQL Server . We want to join multiple tables with the Event table according to their relations as shown on the image below. However, I am not sure if the grouping approach that I used is correct or not because the query takes a lot of time. Could you please clarify me oh how to join these tables by multiple grouping? Here is the JOIN clause I used: SELECT t.CardNo, t.EventTime, t1.EmployeeName, t1.Status, t2.EventCH, t3.DoorName, t4.JobName, t5.DeptName FROM Event t LEFT JOIN Employee AS t1 ON t.EmployeeID = t1

I have a large table with millions of records. Table `price` ------------ id product site value The table is brand new, and there are no indexes created. I then issued a request for new index creation with the following query: CREATE INDEX ix_price_site_product_value_id ON price (site, product, value, id); This took long long time, last time I was checking ran for 5000+ seconds, because of the machine. I am wondering if I issue another index creation, will it use the existing index in the process calculation? If so in what form? Next to run query 1: CREATE INDEX ix_price_product_value_id ON

I have the following huge query that contains repeated subqueries , It looks really inefficient to me. How can i optimize it ? SELECT T2.date1, T2.date2, T2.period, T1.market, T1.ticker, 0 AS scenario FROM (SELECT DISTINCT Q.market AS market, Q.ticker AS ticker FROM portfolio.scenario S RIGHT JOIN portfolio.quote Q ON S.series = (SELECT S.series FROM scenario S WHERE S.date1 >= '2009-09-01' AND S.date2 <= '2010-07-01' AND S.period = 'QUARTER' ORDER BY S.date2 LIMIT 1) AND Q.market = S.market AND Q.ticker = S.ticker WHERE Q.date = '2010-07-01' AND S.date1 IS NULL) AS T1 JOIN (SELECT DISTINCT S

I'm having some troubles understanding what indices to use on a Nested-Set model. The query is: SELECT `node`.`id`,(COUNT(parent.id) - 1) AS `depth`,`name` FROM `categories` AS `parent` INNER JOIN `categories` AS `node` ON (`node`.`lft` BETWEEN parent.lft AND parent.rgt) INNER JOIN `filebank_categories` ON (`node`.`id` = `filebank_categories`.`category_id` AND `filebank_categories`.`filebank_id` = 136) INNER JOIN `categories_names` ON (`categories_names`.`category_id` = `node`.`id` AND `categories_names`.`language_id` = 1) WHERE `node`.`system_id` = parent.system_id GROUP BY node.id ORDER BY

Each time I save() a new domain object in Grails I see Hibernate issuing Select statements for each of the unique constraints in my Grails domain class. If I save without validation, I don't see the Select statements. Example: new Person(name: 'Foo').save(validate: false) Is there a way to stop these extra Select statements from occurring while still having validation enabled? One of my goals is to decrease appserver/database chattiness since I am expecting my Grails app to run on a high latency network (e.g., communicating from Grails app => DB can be costly). Burt has one suggestion, but I'm

My database has the following schema: class Product(models.Model): pass class Tag(models.Model): product = models.ForeignKey(Product) attr1 = models.CharField() attr2 = models.CharField() attr3 = models.CharField() class AlternatePartNumber(models.Model): product = models.ForeignKey(Product) In other words, a Product has many Tag s, and a Product has many AlternatePartNumber s. Tag s are a collection of attributes of the Product . Given the three attributes in a Tag , I want to select the associated Product s that match (could be more than one), as well as all of the AlternatePartNumber s of

I was wondering if adding a LIMIT 1 to a query would speed up the processing? For example... I have a query that will most of the time return 1 result, but will occasionaly return 10's, 100's or even 1000's of records. But I will only ever want the first record. Would the limit 1 speed things up or make no difference? I know I could use GROUP BY to return 1 result but that would just add more computation. Any thoughts gladly accepted! Thanks It depends if you have an ORDER BY. An ORDER BY needs the entire result set anyway, so it can be ordered. If you don't have any ORDER BY it should run

I have a very very complex model with lots of related models by FK and M2M which are also have lots of relations, etc. So, rendering a list of such objects is a very expensive SQL operation, and i want to optimise it. (select_related and prefetch_related help, but a little) I have maybe a very stupid but very simple idea - define save method, that will serialize all object's data to a field stores JSON To do something like this: class VeryComplexModel(models.Model): # some_field # some_field # ... json = models.TextField() def save(self): json = serialize(self) in views.py: complexModels =