Fonctionnalités cachées de MySQL
Je travaille avec Microsoft SQL Server depuis de nombreuses années maintenant, mais je n'ai que récemment commencé à utiliser MySQL avec mes applications Web, et j'ai faim de connaissances.
Pour continuer avec la longue liste de "questions sur les" fonctionnalités cachées " , je voudrais connaître toutes les fonctionnalités cachées ou pratiques de MySQL qui, espérons-le, amélioreront ma connaissance de cette base de données open source.
Depuis que vous avez mis en place une prime, je vais partager mes secrets durement gagnés ...
En général, tous les SQL que j'ai réglés aujourd'hui nécessitent l'utilisation de sous-requêtes. Comme je venais du monde des bases de données Oracle, les choses que je tenais pour acquises ne fonctionnaient pas de la même manière avec MySQL. Et ma lecture sur l'optimisation MySQL me fait conclure que MySQL est derrière Oracle en termes d'optimisation des requêtes.
Alors que les requêtes simples requises pour la plupart des applications B2C peuvent bien fonctionner pour MySQL, la plupart des types de requêtes de rapports agrégés nécessaires pour Intelligence Reporting semblent nécessiter une bonne partie de la planification et de la réorganisation des requêtes SQL pour guider MySQL afin de les exécuter plus rapidement.
Administration:
max_connections est le nombre de connexions simultanées. La valeur par défaut est de 100 connexions (151 depuis 5.0) - très petite.
Remarque:
les connexions prennent de la mémoire et votre système d'exploitation peut ne pas être en mesure de gérer un grand nombre de connexions.
Les binaires MySQL pour Linux/x86 vous permettent d'avoir jusqu'à 4096 connexions simultanées, mais les binaires auto-compilés ont souvent moins de limites.
Définissez table_cache pour qu'il corresponde au nombre de vos tables ouvertes et connexions simultanées. Observez la valeur open_tables et si elle croît rapidement, vous devrez augmenter sa taille.
Remarque:
Les 2 paramètres précédents peuvent nécessiter beaucoup de fichiers ouverts. 20 + max_connections + table_cache * 2 est une bonne estimation de ce dont vous avez besoin. MySQL sur Linux a une option open_file_limit, définissez cette limite.
Si vous avez des requêtes complexes, sort_buffer_size et tmp_table_size sont susceptibles d'être très importants. Les valeurs dépendront de la complexité de la requête et des ressources disponibles, mais 4 Mo et 32 Mo, respectivement, sont des points de départ recommandés.
Remarque: Ce sont des valeurs "par connexion", parmi read_buffer_size, read_rnd_buffer_size et quelques autres, ce qui signifie que cette valeur peut être nécessaire pour chaque connexion. Tenez donc compte de votre charge et des ressources disponibles lorsque vous définissez ces paramètres. Par exemple sort_buffer_size n'est alloué que si MySQL doit faire un tri. Remarque: veillez à ne pas manquer de mémoire.
Si plusieurs connexions sont établies (c'est-à-dire un site Web sans connexions persistantes), vous pouvez améliorer les performances en définissant thread_cache_size sur une valeur non nulle. 16 est une bonne valeur pour commencer. Augmentez la valeur jusqu'à ce que vos threads_created ne grandissent pas très rapidement.
CLÉ PRIMAIRE:
Il ne peut y avoir qu'une seule colonne AUTO_INCREMENT par table, elle doit être indexée et ne peut pas avoir de valeur DEFAULT
KEY est normalement synonyme d'INDEX. L'attribut clé PRIMARY KEY peut également être spécifié comme étant simplement KEY lorsqu'il est donné dans une définition de colonne. Cela a été implémenté pour la compatibilité avec d'autres systèmes de base de données.
Une CLÉ PRIMAIRE est un index unique où toutes les colonnes clés doivent être définies comme NON NUL
Si un index PRIMARY KEY ou UNIQUE se compose d'une seule colonne qui a un type entier, vous pouvez également faire référence à la colonne comme "_rowid" dans les instructions SELECT.
Dans MySQL, le nom d'une CLÉ PRIMAIRE est PRIMAIRE
Actuellement, seules les tables InnoDB (v5.1?) Prennent en charge les clés étrangères.
Habituellement, vous créez tous les index dont vous avez besoin lorsque vous créez des tables. Toute colonne déclarée comme PRIMARY KEY, KEY, UNIQUE ou INDEX sera indexée.
NULL signifie "ne pas avoir de valeur". Pour tester NULL, vous ne pouvez pas utiliser les opérateurs de comparaison arithmétique tels que =, <ou <>. Utilisez les opérateurs IS NULL et IS NOT NULL à la place:
NO_AUTO_VALUE_ON_ZERO supprime l'incrémentation automatique de 0 afin que seul NULL génère le numéro de séquence suivant. Ce mode peut être utile si 0 a été stocké dans la colonne AUTO_INCREMENT d'une table. (Soit dit en passant, le stockage de 0 n'est pas recommandé.)
Pour modifier la valeur du compteur AUTO_INCREMENT à utiliser pour les nouvelles lignes:
ALTER TABLE mytable AUTO_INCREMENT = value;
ou SET INSERT_ID = valeur;
Sauf indication contraire, la valeur commencera par: 1000000 ou le spécifiera ainsi:
...) MOTEUR = MyISAM DEFAULT CHARSET = latin1 AUTO_INCREMENT = 1
TIMESTAMPS:
Les valeurs des colonnes TIMESTAMP sont converties du fuseau horaire actuel en UTC pour le stockage et de l'UTC vers le fuseau horaire actuel pour la récupération.
http://dev.mysql.com/doc/refman/5.1/en/timestamp.html Pour une colonne TIMESTAMP dans une table, vous pouvez affecter l'horodatage actuel comme valeur par défaut et l'auto- mettre à jour la valeur.
une chose à surveiller lors de l'utilisation de l'un de ces types dans une clause WHERE, il est préférable de faire WHERE datecolumn = FROM_UNIXTIME (1057941242) et non WHERE UNIX_TIMESTAMP (datecolumn) = 1057941242. faire ce dernier ne profitera pas d'un index sur cette colonne.
http://dev.mysql.com/doc/refman/5.1/en/date-and-time-functions.html
UNIX_TIMESTAMP()
FROM_UNIXTIME()
UTC_DATE()
UTC_TIME()
UTC_TIMESTAMP()
si vous convertissez un datetime en horodatage unix dans MySQL:
Et puis ajoutez-y 24 heures:
Et puis le reconvertir en un datetime, il perd comme par magie une heure!
Voici ce qui se passe. Lors de la reconversion de l'horodatage Unix en une date et heure, le fuseau horaire est pris en compte et il se trouve que du 28 au 29 octobre 2006, nous avons interrompu l'heure d'été et perdu une heure.
Depuis MySQL 4.1.3, les fonctions CURRENT_TIMESTAMP (), CURRENT_TIME (), CURRENT_DATE () et FROM_UNIXTIME () renvoient des valeurs dans le fuseau horaire actuel de la connexion , qui est disponible comme valeur de la variable système time_zone. De plus, UNIX_TIMESTAMP () suppose que son argument est une valeur datetime dans le fuseau horaire actuel.
Le paramètre de fuseau horaire actuel n'affecte pas les valeurs affichées par des fonctions telles que UTC_TIMESTAMP () ou les valeurs des colonnes DATE, TIME ou DATETIME.
REMARQUE: À LA MISE À JOUR [~ # ~] seulement [~ # ~] met à jour le DateTime si un champ est modifié Si une MISE À JOUR n'entraîne la modification d'aucun champ alors le DateTime n'est PAS mis à jour!
De plus, le premier TIMESTAMP est toujours AUTOUPDATE par défaut même s'il n'est pas spécifié
Lorsque je travaille avec des dates, je convette presque toujours la date julienne car les calculs de données consistent alors simplement à ajouter ou à soustraire des entiers, et des secondes depuis minuit pour la même raison. Il est rare que j'aie besoin d'une résolution temporelle d'une granularité plus fine que quelques secondes.
Les deux peuvent être stockés sous la forme d'un entier de 4 octets, et si l'espace est vraiment restreint, ils peuvent être combinés en temps UNIX (secondes depuis l'Epoque 1/1/1970) en tant qu'entier non signé qui sera valable jusqu'en 2106 comme:
'secondes en 24 heures = 86400
'Entier signé val max = 2147483647 - peut contenir 68 ans de secondes
'Entier non signé valeur max = 4 294 967 295 - peut contenir 136 ans de secondes
Protocole binaire:
MySQL 4.1 a introduit un protocole binaire qui permet d'envoyer et de renvoyer des valeurs de données non-chaîne au format natif sans conversion vers et depuis le format chaîne. (Très utile)
De plus, mysql_real_query () est plus rapide que mysql_query () car il n'appelle pas strlen () pour opérer sur la chaîne d'instruction.
http://dev.mysql.com/tech-resources/articles/4.1/prepared-statements.html Le protocole binaire prend en charge les instructions préparées côté serveur et permet la transmission des valeurs de données au format natif. Le protocole binaire a subi pas mal de révision lors des versions précédentes de MySQL 4.1.
Vous pouvez utiliser la macro IS_NUM () pour tester si un champ a un type numérique. Passez la valeur de type à IS_NUM () et elle est évaluée à TRUE si le champ est numérique:
Une chose à noter est que les données binaires [~ # ~] peuvent [~ # ~] être envoyées dans une requête régulière si vous y échappez et vous souvenez de MySQL nécessite uniquement que la barre oblique inverse et le caractère de citation soient échappés. C'est donc un moyen très simple d'INSERER des chaînes binaires plus courtes comme des mots de passe cryptés/salés par exemple.
Serveur maître:
http://www.experts-exchange.com/Database/MySQL/Q_22967482.html
http://www.databasejournal.com/features/mysql/article.php/10897_3355201_2
GRANT REPLICATION SLAVE ON . to slave_user IDENTIFIED BY 'slave_password'
#Master Binary Logging Config STATEMENT causes replication
to be statement-based - default
log-bin=Mike
binlog-format=STATEMENT
server-id=1
max_binlog_size = 10M
expire_logs_days = 120
#Slave Config
master-Host=master-hostname
master-user=slave-user
master-password=slave-password
server-id=2
Le fichier journal binaire doit lire:
http://dev.mysql.com/doc/refman/5.0/en/binary-log.html
http://www.mydigitallife.info/2007/10/06/how-to-read-mysql-binary-log-files-binlog-with-mysqlbinlog/
http://dev.mysql.com/doc/refman/5.1/en/mysqlbinlog.html
http://dev.mysql.com/doc/refman/5.0/en/binary-log.html
http://dev.mysql.com/doc/refman/5.1/en/binary-log-setting.html
Vous pouvez supprimer tous les fichiers journaux binaires avec l'instruction RESET MASTER, ou un sous-ensemble d'entre eux avec PURGE MASTER
--result-file = binlog.txt TrustedFriend-bin.000030
Normalisation:
http://dev.mysql.com/tech-resources/articles/intro-to-normalization.html
Fonctions UDF
http://www.koders.com/cpp/fid10666379322B54AD41AEB0E4100D87C8CDDF1D8C.aspx
http://souptonuts.sourceforge.net/readme_mysql.htm
Types de données:
http://dev.mysql.com/doc/refman/5.1/en/storage-requirements.html
http://www.informit.com/articles/article.aspx?p=1238838&seqNum=2
http://bitfilm.net/2008/03/24/saving-bytes-efficient-data-storage-mysql-part-1/
Une chose à noter est que sur une table mixte avec CHAR et VARCHAR, mySQL changera les CHAR en VARCHAR
RecNum integer_type UNSIGNED NOT NULL AUTO_INCREMENT, PRIMARY KEY (RecNum)
MySQL représente toujours les dates avec l'année en premier, conformément aux spécifications standard SQL et ISO 8601
Divers:
Turing off certaines fonctionnalités MySQl se traduira par des fichiers de données plus petits et un accès plus rapide. Par exemple:
--datadir spécifiera le répertoire de données et
--skip-innodb désactivera l'option inno et vous fera économiser 10-20M
Plus ici http://dev.mysql.com/tech-resources/articles/mysql-c-api.html
Télécharger le chapitre 7 - gratuit
InnoDB est transactionnel mais il y a un surcoût de performance qui l'accompagne. J'ai trouvé que les tables MyISAM étaient suffisantes pour 90% de mes projets. Les tables non sécurisées pour les transactions (MyISAM) ont leurs propres avantages, qui se produisent tous parce que:
il n'y a pas de frais généraux de transaction:
Plus vite
Besoins d'espace disque réduits
Moins de mémoire requise pour effectuer des mises à jour
Chaque table MyISAM est stockée sur disque dans trois fichiers. Les fichiers ont des noms qui commencent par le nom de la table et ont une extension pour indiquer le type de fichier. Un fichier .frm stocke le format de la table. Le fichier de données a une extension .MYD (MYData). Le fichier d'index a une extension .MYI (MYIndex).
Ces fichiers peuvent être copiés dans un emplacement de stockage intact sans utiliser la fonction de sauvegarde des administrateurs MySQL qui prend du temps (tout comme la restauration)
L'astuce consiste à faire une copie de ces fichiers puis à supprimer la table. Lorsque vous remettez les fichiers en arrière, MySQl les reconnaît et met à jour le suivi des tables.
Si vous devez sauvegarder/restaurer,
La restauration d'une sauvegarde ou l'importation à partir d'un fichier de vidage existant peut prendre beaucoup de temps en fonction du nombre d'index et de clés primaires que vous avez sur chaque table. Vous pouvez accélérer considérablement ce processus en modifiant votre fichier de vidage d'origine en l'entourant de ce qui suit:
SET AUTOCOMMIT = 0;
SET FOREIGN_KEY_CHECKS=0;
.. your dump file ..
SET FOREIGN_KEY_CHECKS = 1;
COMMIT;
SET AUTOCOMMIT = 1;
Pour augmenter considérablement la vitesse de rechargement, ajoutez la commande SQL SET AUTOCOMMIT = 0; au début du fichier de vidage, et ajoutez le COMMIT; jusqu'à la fin.
Par défaut, la validation automatique est activée, ce qui signifie que chaque commande d'insertion dans le fichier de vidage sera traitée comme une transaction distincte et écrite sur le disque avant le démarrage de la suivante. Si vous n'ajoutez pas ces commandes, le rechargement d'une grande base de données dans InnoDB peut prendre plusieurs heures ...
La taille maximale d'une ligne dans une table MySQL est de 65 535 octets
La longueur maximale effective d'un VARCHAR dans MySQL 5.0.3 et activé = taille de ligne maximale (65 535 octets)
Les valeurs VARCHAR ne sont pas complétées lorsqu'elles sont stockées. Les espaces de fin sont conservés lorsque les valeurs sont stockées et récupérées, conformément au SQL standard.
Les valeurs CHAR et VARCHAR dans MySQL sont comparées sans tenir compte des espaces de fin.
L'utilisation de CHAR n'accélérera votre accès que si la totalité de l'enregistrement est de taille fixe. Autrement dit, si vous utilisez un objet de taille variable, vous pouvez tout aussi bien les rendre tous de taille variable. Vous ne gagnez aucune vitesse en utilisant un CHAR dans une table qui contient également un VARCHAR.
La limite VARCHAR de 255 caractères a été augmentée à 65 535 caractères à partir de MySQL 5.0.3
Les recherches en texte intégral sont prises en charge pour les tables MyISAM uniquement.
http://dev.mysql.com/doc/refman/5.0/en/fulltext-search.html
Les colonnes BLOB n'ont pas de jeu de caractères, et le tri et la comparaison sont basés sur les valeurs numériques des octets dans les valeurs de colonne
Si le mode SQL strict n'est pas activé et que vous affectez une valeur à une colonne BLOB ou TEXT qui dépasse la longueur maximale de la colonne, la valeur est tronquée pour s'adapter et un avertissement est généré.
Commandes utiles:
vérifier le mode strict: SELECT @@ global.sql_mode;
désactiver le mode strict:
SET @@ global.sql_mode = '';
SET @@ global.sql_mode = 'MYSQL40'
ou supprimez: sql-mode = "STRICT_TRANS_TABLES, ...
AFFICHER LES COLONNES DE mytable
SELECT max (namecount) AS virtualcolumn FROM mytable ORDER BY virtualcolumn
http://dev.mysql.com/doc/refman/5.0/en/group-by-hidden-fields.html
http://dev.mysql.com/doc/refman/5.1/en/information-functions.html#function_last-insert-id last_insert_id ()
vous obtient le PK de la dernière ligne insérée dans le thread actuel max (pkcolname) vous obtient le dernier PK global.
Remarque: si la table est vide, max (pkcolname) renvoie 1 mysql_insert_id () convertit le type de retour de la fonction native de l'API MySQL C mysql_insert_id () en un type long (nommé int en PHP).
Si votre colonne AUTO_INCREMENT a un type de colonne BIGINT, la valeur retournée par mysql_insert_id () sera incorrecte. Utilisez plutôt la fonction interne MySQL SQL LAST_INSERT_ID () dans une requête SQL.
http://dev.mysql.com/doc/refman/5.0/en/information-functions.html#function_last-insert-id
Juste une note que lorsque vous essayez d'insérer des données dans une table et que vous obtenez l'erreur:
Unknown column ‘the first bit of data what you want to put into the table‘ in ‘field list’
en utilisant quelque chose comme
INSERT INTO table (this, that) VALUES ($this, $that)
c'est parce que vous n'avez pas d'apostrophes autour des valeurs que vous essayez de coller dans le tableau. Vous devez donc changer votre code pour:
INSERT INTO table (this, that) VALUES ('$this', '$that')
rappel que `` sont utilisés pour définir des champs, bases de données ou tables MySQL, pas des valeurs;)
Connexion perdue au serveur pendant la requête:
http://dev.mysql.com/doc/refman/5.1/en/gone-away.html
http://dev.mysql.com/doc/refman/5.1/en/packet-too-large.html
http://dev.mysql.com/doc/refman/5.0/en/server-parameters.html
http://dev.mysql.com/doc/refman/5.1/en/show-variables.html
http://dev.mysql.com/doc/refman/5.1/en/option-files.html
http://dev.mysql.com/doc/refman/5.1/en/error-log.html
Optimisation des requêtes
http://www.artfulsoftware.com/infotree/queries.php?&bw=131
Eh bien, cela devrait suffire pour gagner le bonus je pense ... Les fruits de nombreuses heures et de nombreux projets avec une excellente base de données gratuite Je développe des serveurs de données d'application sur des plates-formes Windows principalement avec MySQL. Le pire désordre que j'ai dû redresser était
Le cauchemar ultime de la base de données MySQL
Cela a nécessité une série d'applications pour transformer les tables en quelque chose d'utile en utilisant la plupart des astuces mentionnées ici.
Si vous avez trouvé cela incroyablement utile, exprimez vos remerciements en le votant.
Consultez également mes autres articles et livres blancs sur: www.coastrd.com
L'une des fonctionnalités moins cachées de MySQL est qu'il n'est pas vraiment bon pour être conforme à SQL, enfin, pas vraiment de bugs, mais en plus gotchas ... :-)
Une commande pour savoir quelles tables sont actuellement dans le cache:
mysql> SHOW open TABLES FROM test;
+----------+-------+--------+-------------+
| DATABASE | TABLE | In_use | Name_locked |
+----------+-------+--------+-------------+
| test | a | 3 | 0 |
+----------+-------+--------+-------------+
1 row IN SET (0.00 sec)
Une commande pour savoir qui fait quoi:
mysql> show processlist;
show processlist;
+----+-------------+-----------------+------+---------+------+----------------------------------+------------------+
| Id | User | Host | db | Command | Time | State | Info |
+----+-------------+-----------------+------+---------+------+----------------------------------+------------------+
| 1 | root | localhost:32893 | NULL | Sleep | 0 | | NULL |
| 5 | system user | | NULL | Connect | 98 | Waiting for master to send event | NULL |
| 6 | system user | | NULL | Connect | 5018 | Reading event from the relay log | NULL |
+-----+------+-----------+---------+---------+-------+-------+------------------+
3 rows in set (0.00 sec)
Et vous pouvez tuer un processus avec:
mysql>kill 5
J'aime particulièrement le support intégré de MySQL pour inet_ntoa() et inet_aton(). Cela rend la gestion des adresses IP dans les tableaux très simple (au moins tant qu'il ne s'agit que d'adresses IPv4!)
J'adore on duplicate key (AKA upsert, merge) pour toutes sortes de compteurs créés paresseusement:
insert into occurances(Word,count) values('foo',1),('bar',1)
on duplicate key cnt=cnt+1
Vous pouvez insérer plusieurs lignes dans une même requête et gérer immédiatement un index en double pour chacune des lignes.
La commande "pager" dans le client
Si vous avez, disons, 10 000 lignes dans votre résultat et que vous souhaitez les afficher (cela suppose que les commandes "moins" et "tee" disponibles, ce qui est normalement le cas sous Linux; dans Windows YMMV.)
pager less
select lots_of_stuff FROM tbl WHERE clause_which_matches_10k_rows;
Et vous les obtiendrez dans la visionneuse de fichiers "moins" afin que vous puissiez les parcourir joliment, rechercher etc.
Aussi
pager tee myfile.txt
select a_few_things FROM tbl WHERE i_want_to_save_output_to_a_file;
Écrira facilement dans un fichier.
Certaines choses peuvent vous intéresser:
<query>\G -- \G in the CLI instead of the ; will show one column per row
explain <query>; -- this will show the execution plan for the query
Pas une fonctionnalité cachée, mais néanmoins utile: http://mtop.sourceforge.net/
Je ne pense pas que ce soit spécifique à MySQL, mais éclairant pour moi:
Au lieu d'écrire
WHERE (x.id > y.id) OR (x.id = y.id AND x.f2 > y.f2)
Vous pouvez simplement écrire
WHERE (x.id, x.f2) > (y.id, y.f2)
Voici quelques-uns de mes conseils - j'ai blogué à leur sujet dans mon blog ( Link )
- Vous n'avez pas besoin d'utiliser le signe '@' pour déclarer des variables.
- Vous devez utiliser un délimiteur (la valeur par défaut est ';') pour délimiter la fin d'une instruction - Link
- Si vous essayez de déplacer des données entre MS-SQL 2005 et mySQL, il y a quelques cercles à franchir - Link
- Faire des correspondances sensibles à la casse dans mySQL - link
Si vous utilisez cmdline Mysq, vous pouvez interagir avec la ligne de commande (sur les machines Linux - vous ne savez pas s'il y a un effet équivalent sur Windows) en utilisant le cri perçant/exclamation. Par exemple:
\! cat file1.sql
affichera le code de file1.sql. Pour enregistrer votre relevé et votre requête dans un fichier, utilisez la fonction tee
\T filename
pour désactiver cette option, utilisez\t
Enfin, pour exécuter un script que vous avez déjà enregistré, utilisez "nom de fichier source". Bien sûr, l'alternative normale consiste à indiquer le nom du script lors du démarrage de mysql à partir de la ligne de commande:
mysql -u root -p < case1.sql
J'espère que cela est utile à quelqu'un!
Edit: Je me souviens juste d'un autre - lorsque vous appelez mysql à partir de la ligne de commande, vous pouvez utiliser le commutateur -t pour que la sortie soit au format tableau - une véritable aubaine pour certaines requêtes (bien que, bien sûr, terminer les requêtes avec\G comme mentionné ailleurs ici soit également utile à cet égard). Beaucoup plus sur divers commutateurs Outil de ligne de commande
Je viens de découvrir un moyen pratique de modifier l'ordre de tri (utilisez normalement Case ...) Si vous souhaitez modifier l'ordre de tri (peut-être trier par 1, 4, 3, 2 au lieu de 1, 2, 3, 4) vous pouvez utiliser la fonction de champ dans la clause Order by. Par exemple
Trier par champ (sort_field, 1,4,3,2)
- Trouvé ici ordre par day_of_week dans MySQL courtoisie de l'utilisateur gms8994
Si vous allez travailler avec des bases de données InnoDb à transactions importantes et/ou importantes, apprenez et comprenez "SHOW INNODB STATUS" Mysql Performance Blog , il deviendra votre ami.
En fait documenté , mais très ennuyeux: conversions automatiques pour des dates incorrectes et autres entrées incorrectes.
Avant MySQL 5.0.2, MySQL pardonne les valeurs de données illégales ou incorrectes et les contraint aux valeurs légales pour la saisie de données. Dans MySQL 5.0.2 et versions ultérieures, cela reste le comportement par défaut, mais vous pouvez modifier le mode SQL du serveur pour sélectionner un traitement plus traditionnel des mauvaises valeurs de sorte que le serveur les rejette et abandonne l'instruction dans laquelle elles se produisent.
En ce qui concerne les dates: parfois, vous serez "chanceux" lorsque MySQL n'ajuste pas l'entrée aux dates valides à proximité, mais les stocke à la place comme 0000-00-00 qui, par définition, n'est pas valide. Cependant, même alors, vous auriez pu souhaiter que MySQL échoue plutôt que de stocker cette valeur en silence pour vous.
mysqlsla - L'un des outils d'analyse de journal de requêtes lentes les plus couramment utilisés. Vous pouvez voir les 10 requêtes les plus graves depuis le dernier déploiement des journaux de requêtes lentes. Il peut également vous indiquer le nombre de fois que la requête BAD a été déclenchée et combien de temps total cela a pris sur le serveur.
Lors de mes tests de performances avec de grands ensembles de données et des champs DATETIME, il est toujours plus lent de faire cette requête:
SELECT * FROM mytable
WHERE date(date_colum) BETWEEN '2011-01-01' AND ''2011-03-03';
Que cette approche:
SELECT * FROM mytable
WHERE date_column BETWEEN '2011-01-01 00:00:00' AND '2011-03-03 23:59:59'
InnoDB stocke par défaut toutes les tables dans un espace de table global qui ne rétrécira jamais .
Vous pouvez utiliser innodb_file_per_table qui placera chaque table dans un espace de table distinct qui sera supprimé lorsque vous supprimerez la table ou la base de données.
Planifiez à l'avance pour cela car vous devez vider et restaurer la base de données pour récupérer de l'espace autrement.
Si vous insérez dans la colonne datetime une valeur de chaîne vide "", MySQL conservera la valeur 00/00/0000 00:00:00. Contrairement à Oracle, qui enregistre une valeur nulle.