Arbeiten mit großen (Dutzende von Millionen von Zeilen) Datensätzen

Question

Für eine einfache Webanwendung ist die Hauptanforderung, so schnell wie möglich rund 30 (10m * 3 Tabellen) Millionen Datensätze zu verarbeiten. Ich habe noch nicht mit so vielen Daten gearbeitet und würde daher gerne Vorschläge von erfahrenen Leuten erhalten.

Die Datenbank wird Details von Unternehmen enthalten. Etwa 25 Attribute beschreiben ein einzelnes Geschäft; Name, Adresse usw. Die Tabellenstruktur ist wie folgt.

CREATE TABLE IF NOT EXISTS `businesses` (
    `id` bigint(20) NOT NULL AUTO_INCREMENT, 
    `type` int(2) NOT NULL, 
    `organisation` varchar(40) NOT NULL, 
    `title` varchar(12) NOT NULL, 
    `given_name` varchar(40) NOT NULL, 
    `other_name` varchar(40) NOT NULL, 
    `family_name` varchar(40) NOT NULL, 
    `suffix` varchar(5) NOT NULL, 
    `reg_date` date NOT NULL, 
    `main_trade_name` varchar(150) NOT NULL, 
    `son_address_l1` varchar(50) NOT NULL, 
    `son_address_l2` varchar(50) NOT NULL, 
    `son_address_suburb` int(3) NOT NULL, 
    `son_address_state` int(2) NOT NULL, 
    `son_address_postcode` varchar(10) NOT NULL, 
    `son_address_country` int(3) NOT NULL, 
    `bus_address_l1` varchar(50) NOT NULL, 
    `bus_address_l2` varchar(50) NOT NULL, 
    `bus_address_suburb` int(3) NOT NULL, 
    `bus_address_state` int(2) NOT NULL, 
    `bus_address_postcode` varchar(10) NOT NULL, 
    `bus_address_country` int(3) NOT NULL, 
    `email` varchar(165) DEFAULT NULL, 
    `phone` varchar(12) NOT NULL, 
    `website` varchar(80) NOT NULL, 
    `employee_size` int(4) NOT NULL, 
    PRIMARY KEY (`id`), 
    KEY `type` (`type`), 
    KEY `phone` (`phone`), 
    KEY `reg_date` (`reg_date`), 
    KEY `son_address_state` (`son_address_state`), 
    KEY `bus_address_state` (`bus_address_state`), 
    KEY `son_address_country` (`son_address_country`), 
    KEY `bus_address_country` (`bus_address_country`), 
    FULLTEXT KEY `title` (`title`), 
    FULLTEXT KEY `son_address_l1` (`son_address_l1`), 
    FULLTEXT KEY `son_address_l2` (`son_address_l2`), 
    FULLTEXT KEY `bus_address_l1` (`bus_address_l1`), 
    FULLTEXT KEY `bus_address_l2` (`bus_address_l2`) 
) ENGINE=MyISAM; 

Es geht 2 weitere Tische so sein, Grund jedes Geschäftsdetails zu sein wird (zu Vergleichszwecken) in 3 Quellen präsentiert. Nur eine Tabelle wird Schreibvorgänge haben.

Über die App-Nutzung,

1. Wenige schreibt, viel liest.
2. 10 * 3 Millionen Daten werden nicht über die Zeit hinaus eingefügt, es wird zuerst eingefügt.
3. App wird nicht viele Anfragen haben, < 10 Anfragen pro Sekunde.
4. Nach dem erstmaligen Laden der Daten werden die Benutzer diese Details aktualisieren. Vergleichen der Daten einer Tabelle mit anderen 2 und Aktualisieren der Daten in der ersten Tabelle.
5. Es wird viele Suchen geben, hauptsächlich nach Name, Adresse, Telefon und Staat. Die einzelne Suche wird alle 3 Tabellen durchlaufen. Das Suchen muss schnell sein.
6. Hobeln es

Meine Fragen sind,

1. Ist es mit PHP zu bauen Wert innerhalb einer Tabelle 3 Quellen eher zu handhaben als 3 Tische mit?
2. Kann MySQL eine gute Lösung bieten?
3. Kann MongoDB dasselbe Szenario mit weniger Hardwareressourcen verarbeiten?
4. Was ist der beste Weg, eine Beispieldatenbank zum Testen einzurichten? Ich kaufte ein Amazon RDS (groß) und legte 10000 Datensätze ein und verdoppelte sie, bis ich 10 Millionen Datensätze bekam.
5. Haben Sie eine gute Lektüre zu diesem Thema?

Vielen Dank.

Answer 1

Ich kann nicht auf Ihre direkte Frage antworten, aber ich habe Erfahrung mit großen Datensätzen zu arbeiten.

Die erste Sache, die ich ausarbeiten würde, ist, was die meisten Anwendungsfall (in Ihrem Fall suchen) Operationen wäre, und dann betrachten Sie die Datenspeicherung/Partitionierung auf der Grundlage.

Als nächstes wird gemessen, gemessen und erneut gemessen. Einige Datenbanksysteme funktionieren gut mit einer Art von Operation und andere mit anderen. Wenn die Datenmenge zunimmt und die betriebliche Komplexität zunimmt, können Dinge, die gut funktionieren, anfangen, sich zu verschlechtern. Deshalb messen Sie - versuchen Sie nicht, dies ohne einen guten Beweis dafür zu entwerfen, wie die von Ihnen verwendeten db-Systeme unter diesen Lasten arbeiten.

Und dann arbeiten Sie iterativ zum Hinzufügen von mehr Operationen.

Versuchen Sie nicht, eine beste Passform für alle zu deignn.Während Sie Design und Forschung destillieren, werden Sie Orte sehen, an denen Optimierungen benötigt werden oder verfügbar sind. Möglicherweise finden Sie auch in der Vergangenheit, dass verschiedene Arten von Caching und Indexierung zu unterschiedlichen Zeiten verwendet werden können.

Viel Glück - klingt wie ein interessantes Projekt.