Którego zapytania użyć?, Dla znacznej puli wyników? Opcje

[darko]

Witam mam następujące dwie tabele:

tabela klienci

[SQL] pobierz, plaintext 
CREATE TABLE  `customers` (
  `id_customers` int(11) NOT NULL AUTO_INCREMENT,
  `id_advisors` int(11) NOT NULL DEFAULT '1',
  `id_consulting_companies` int(11) NOT NULL,
  `id_managers` int(11) NOT NULL,
  `id_users` int(11) NOT NULL,
  `name` varchar(55) NOT NULL,
  `surname` varchar(60) NOT NULL,
  `address_street` varchar(255) NOT NULL,
  `address_city` varchar(255) NOT NULL,
  `address_postal` varchar(7) NOT NULL,
  `phone` varchar(15) NOT NULL,
  `mobile` varchar(12) NOT NULL,
  `email` varchar(55) NOT NULL,
  `notes` text,
  `status` tinyint(1) NOT NULL DEFAULT '1',
  PRIMARY KEY  (`id_customers`),
  KEY `fk_adv` (`id_advisors`),
  KEY `fk_consult_cmpny` (`id_consulting_companies`),
  KEY `fk_usr3` (`id_users`),
  KEY `fk_mana` (`id_managers`),
  CONSTRAINT `fk_adv` FOREIGN KEY (`id_advisors`) REFERENCES `advisors` (`id_advisors`) ON DELETE NO ACTION ON UPDATE NO ACTION,
  CONSTRAINT `fk_consult_cmpny` FOREIGN KEY (`id_consulting_companies`) REFERENCES `consulting_companies` (`id_consulting_companies`) ON DELETE NO ACTION ON UPDATE NO ACTION,
  CONSTRAINT `fk_mana` FOREIGN KEY (`id_managers`) REFERENCES `managers` (`id_managers`) ON DELETE NO ACTION ON UPDATE NO ACTION,
  CONSTRAINT `fk_usr3` FOREIGN KEY (`id_users`) REFERENCES `users` (`id_users`) ON DELETE NO ACTION ON UPDATE NO ACTION
) ENGINE=InnoDB AUTO_INCREMENT=1 DEFAULT CHARSET=utf8
[SQL] pobierz, plaintext 

oraz tabela testy klientów

[SQL] pobierz, plaintext 
CREATE TABLE  `customers_tests` (
  `id_customers_tests` int(11) NOT NULL AUTO_INCREMENT,
  `id_customers` int(11) NOT NULL DEFAULT '1' ,
  `id_tests_versions` int(11) NOT NULL DEFAULT '1' ,
  `result` int(11) NOT NULL DEFAULT '1',
  `profile` tinyint(1) DEFAULT NULL,
  `test_date` datetime DEFAULT NULL,
  `notes` text,
  `status` tinyint(1) NOT NULL,
  PRIMARY KEY  (`id_customers_tests`),
  KEY `fk_customer` (`id_customers`),
  KEY `fk_tv` (`id_tests_versions`),
  CONSTRAINT `fk_customer` FOREIGN KEY (`id_customers`) REFERENCES `customers` (`id_customers`) ON DELETE NO ACTION ON UPDATE NO ACTION,
  CONSTRAINT `fk_tv` FOREIGN KEY (`id_tests_versions`) REFERENCES `tests_versions` (`id_tests_versions`) ON DELETE NO ACTION ON UPDATE NO ACTION
) ENGINE=InnoDB AUTO_INCREMENT=1 DEFAULT CHARSET=utf8
[SQL] pobierz, plaintext 

I mam trzy zapytania wyciągające dane zawarte w tabeli klienci, ale nie mające równoważnych rekordów w drugiej tabeli testy. Oto te zapytania:
1)

[SQL] pobierz, plaintext 
SELECT *
FROM customers
WHERE NOT EXISTS (SELECT * FROM customers_tests WHERE customers.id_customers = customers_tests.id_customers)
[SQL] pobierz, plaintext 

2)

[SQL] pobierz, plaintext 
SELECT * FROM customers c, customers_tests t WHERE c.id_customers <> t.id_customers
[SQL] pobierz, plaintext 

oraz 3)

[SQL] pobierz, plaintext 
SELECT * FROM customers
   LEFT JOIN customers_tests ON customers.id_customers = customers_tests.id_customers
   WHERE customers_tests.id_customers IS NULL
[SQL] pobierz, plaintext 

I teraz pytanie: zakładając, że będzie bardzo dużo (setki tysięcy) rekordów spełniających warunek: rekord w tabeli podstawowej, ale brak w tej drugiej, którego zapytania użyć najlepiej? Nie mam tylu danych, żeby sprawdzić i porobić testy. W sumie zależy mi na odpowiedzi co do zasady, jak postępować w takich sytuacjach.
ps. silnik InnoDB; select version() zwraca: Mysql 5.0.51a-24+lenny2+spu1
Pozdrawiam.
darko

[erix]

Nie mam tylu danych, żeby sprawdzić i porobić testy.

A nie możesz ich wygenerować?

[Mchl]

1) Podzapytanie skorelowane, czyli coś czego chcemy unikać
2) To w ogóle daje Ci takie wyniki jak chcesz?

[darko]

Dzięki za odpowiedzi. Odnośnie tworzenia mega zbioru rekordów na potrzeby testów - ok jak tylko znajdę chwilę - zrobię testy porównując czasy. Jaka pula rekordów byłaby miarodajna? Generalnie chodzi mi o to co jest bardziej wydajne w poleceniach select: operacje na indeksach czy korzystanie z joinów?
~Mchl - 1) skreślam z listy. 2) tak, wszystkie 3 zapytania zwracają poprawne dane.

[Mchl]

Ad 2) Moim zdaniem mylisz się, albo nie rozumiem co chcesz uzyskać.

Jeżeli będziesz miał w tabeli customers rekordy o id_customers 1,2,3,4 a w tabeli customers_test rekordy o id_customers 2, 4 to w wyniku tego zapytania dostaniesz:

Kod

c.id_customers, t.id_customers
1,2
1,4
2,4
3,2
3,4
4,2

[darko]

Faktycznie Umknęło mi to.

[puc]

najszybszy powinien być left join (rozwiązanie 3)

[PHP] pobierz, plaintext 
SELECT * FROM customers
LEFT JOIN customers_tests ON customers.id_customers = customers_tests.id_customers
WHERE customers_tests.id_customers IS NULL
[PHP] pobierz, plaintext 

kiedyś testowałem i jest to naprawdę wydajne. przy czym jeżeli zależy ci bardzo na wydajności to zrezygnuj z * na rzecz wylistowania ręcznego kolumn