Quel type de données MySQL doit être utilisé pour Latitude / Longitude avec 8 décimales?

Je travaille avec des données cartographiques, et le Latitude/Longitudeétend à 8 décimales. Par exemple:

Latitude 40.71727401
Longitude -74.00898606

J'ai vu dans le document Google qui utilise:

lat FLOAT( 10, 6 ) NOT NULL,  
lng FLOAT( 10, 6 ) NOT NULL

cependant, leur décimale ne passe qu'à 6.
Dois-je utiliser FLOAT(10, 8)ou existe-t-il une autre méthode à considérer pour stocker ces données afin qu'elles soient précises. Il sera utilisé avec des calculs de carte. Merci!

DECIMAL est le type de données MySQL pour l'arithmétique exacte. Contrairement à FLOAT, sa précision est fixée pour n'importe quelle taille de nombre, donc en l'utilisant à la place de FLOAT, vous pouvez éviter les erreurs de précision lors de certains calculs. Si vous stockiez et récupériez simplement les nombres sans calcul, alors dans la pratique, FLOAT serait sûr, bien qu'il n'y ait aucun mal à utiliser DECIMAL. Avec les calculs, FLOAT est toujours correct, mais pour être absolument sûr de 8d.p. précision, vous devez utiliser DECIMAL.

Les latitudes varient de -90 à +90 (degrés), donc DECIMAL (10, 8) est correct pour cela, mais les longitudes varient de -180 à +180 (degrés), vous avez donc besoin de DECIMAL (11, 8). Le premier nombre est le nombre total de chiffres stockés et le second est le nombre après la virgule décimale.

En bref: lat DECIMAL(10, 8) NOT NULL, lng DECIMAL(11, 8) NOT NULL

Cela explique comment MySQL fonctionne avec les types de données à virgule flottante.

MISE À JOUR: MySQL prend en charge les types de données spatiales et Pointest un type à valeur unique qui peut être utilisé. Exemple:

CREATE TABLE `buildings` (
  `coordinate` POINT NOT NULL,
  /* Even from v5.7.5 you can define an index for it */
  SPATIAL INDEX `SPATIAL` (`coordinate`)
) ENGINE=InnoDB;

/* then for insertion you can */
INSERT INTO `buildings` 
(`coordinate`) 
VALUES
(POINT(40.71727401 -74.00898606));

De plus, vous verrez que les floatvaleurs sont arrondies.

// ex: valeurs données 41.0473112,29.0077011

flotteur (11,7) | décimal (11,7)
---------------------------
41.0473099 | 41.0473112
29.0077019 | 29.0077011

dans laravel utilisé le type de colonne décimale pour la migration

$table->decimal('latitude', 10, 8);
$table->decimal('longitude', 11, 8);

pour plus d'informations, voir le type de colonne disponible

Vous pouvez définir votre type de données comme entier signé. Lorsque vous stockez les coordonnées en SQL, vous pouvez définir comme lat * 10000000 et long * 10000000. Et lorsque vous sélectionnez avec distance / rayon, vous divisez les coordonnées de stockage à 10000000. Je l'ai testé avec 300K lignes, le temps de réponse aux requêtes est bon. (2 x 2,67 GHz, 2 Go de RAM, MySQL 5.5.49)

N'utilisez pas de flotteur ... Il arrondira vos coordonnées, ce qui entraînera des événements étranges.

Utiliser décimal

MySQL prend désormais en charge les types de données spatiales depuis que cette question a été posée. La réponse actuellement acceptée n'est donc pas fausse, mais si vous recherchez des fonctionnalités supplémentaires telles que la recherche de tous les points dans un polygone donné, utilisez le type de données POINT.

Consultez la documentation de Mysql sur les types de données géospatiales et les fonctions d'analyse spatiale

Je crois que la meilleure façon de stocker Lat / Lng dans MySQL est d'avoir une colonne POINT (type de données 2D) avec un index SPATIAL.

CREATE TABLE `cities` (
  `zip` varchar(8) NOT NULL,
  `country` varchar (2) GENERATED ALWAYS AS (SUBSTRING(`zip`, 1, 2)) STORED,
  `city` varchar(30) NOT NULL,
  `centre` point NOT NULL,
  PRIMARY KEY (`zip`),
  KEY `country` (`country`),
  KEY `city` (`city`),
  SPATIAL KEY `centre` (`centre`)
) ENGINE=InnoDB;


INSERT INTO `cities` (`zip`, `city`, `centre`) VALUES
('CZ-10000', 'Prague', POINT(50.0755381, 14.4378005));

Utilisation de Migrate Ruby sur des rails

class CreateNeighborhoods < ActiveRecord::Migration[5.0]
  def change
    create_table :neighborhoods do |t|
      t.string :name
      t.decimal :latitude, precision: 15, scale: 13
      t.decimal :longitude, precision: 15, scale: 13
      t.references :country, foreign_key: true
      t.references :state, foreign_key: true
      t.references :city, foreign_key: true

      t.timestamps
    end
  end
end

Code pour utiliser / prouver la précision de la réponse d' Oğuzhan KURNUÇ .

RÉSUMÉ:
Grande précision (~ 1 cm) dans une petite taille (4B).

La précision est (très proche de) 7 chiffres décimaux pour les valeurs supérieures à la plage [-180, 180].
Cela fait 7 chiffres à droite de la décimale (~ 1 cm) , pour un total de 9 chiffres (ou 10 chiffres, si l'on compte le "1" initial de "180") près de + -180.
Comparez cela avec un flottant de 4 octets , qui n'a que ~ 7 chiffres au total, donc ~ 5 chiffres à droite de la décimale près de + = 180 (~ 1 m) .

Méthodes pour utiliser cette approche:

const double Fixed7Mult = 10000000;

public static int DecimalDegreesToFixed7(double degrees)
{
    return RoundToInt(degrees * Fixed7Mult);
}

public static double Fixed7ToDecimalDegrees(int fixed7)
{
    return fixed7 / (double)Fixed7Mult;
}

Tests de précision:

/// <summary>
/// This test barely fails in 7th digit to right of decimal point (0.0000001 as delta).
/// Passes with 0.0000002 as delta.
/// </summary>
internal static void TEST2A_LatLongPrecision()
{
    //VERY_SLOW_TEST Test2A_ForRange(-180, 360, 0.0000001);
    //FAILS Test2A_ForRange(-180, 0.1, 0.0000001);

    Test2A_ForRange(-180, 0.1, 0.0000002);
    Test2A_ForRange(0, 0.1, 0.0000002);
    Test2A_ForRange(179.9, 0.1, 0.0000002);
}

/// <summary>
/// Test for the smallest difference.  A: 9.9999994E-08.
/// </summary>
internal static void TEST2B_LatLongPrecision()
{
    double minDelta = double.MaxValue;
    double vAtMinDelta = 0;
    //VERY_SLOW_TEST Test2B_ForRange(-180, 360, ref minDelta, ref vAtMinDelta);
    Test2B_ForRange(-180, 0.1, ref minDelta, ref vAtMinDelta);
    Test2B_ForRange(0, 0.1, ref minDelta, ref vAtMinDelta);
    Test2B_ForRange(179.9, 0.1, ref minDelta, ref vAtMinDelta);

    // Fails. Smallest delta is 9.9999994E-08; due to slight rounding error in 7th decimal digit.
    //if (minDelta < 0.0000001)
    //  throw new InvalidProgramException($"Fixed7 has less than 7 decimal digits near {vAtMinDelta}");

    // Passes.
    if (minDelta < 0.000000099)
        throw new InvalidProgramException($"Fixed7 has less than 7 decimal digits near {vAtMinDelta}");
}

Méthodes auxiliaires utilisées par les tests:

private static void Test2A_ForRange(double minV, double range, double deltaV)
{
    double prevV = 0;
    int prevFixed7 = 0;
    bool firstTime = true;
    double maxV = minV + range;
    for (double v = minV; v <= maxV; v += deltaV) {
        int fixed7 = DecimalDegreesToFixed7(v);
        if (firstTime)
            firstTime = false;
        else {
            // Check for failure to distinguish two values that differ only in 7th decimal digit.
            // Fails.
            if (fixed7 == prevFixed7)
                throw new InvalidProgramException($"Fixed7 doesn't distinguish between {prevV} and {v}");
        }
        prevV = v;
        prevFixed7 = fixed7;
    }
}

private static void Test2B_ForRange(double minV, double range, ref double minDelta, ref double vAtMinDelta)
{
    int minFixed7 = DecimalDegreesToFixed7(minV);
    int maxFixed7 = DecimalDegreesToFixed7(minV + range);

    bool firstTime = true;
    double prevV = 0;   // Initial value is ignored.
    for (int fixed7 = minFixed7; fixed7 < maxFixed7; fixed7++) {
        double v = Fixed7ToDecimalDegrees(fixed7);
        if (firstTime)
            firstTime = false;
        else {
            double delta = Math.Abs(v - prevV);
            if (delta < minDelta) {
                minDelta = delta;
                vAtMinDelta = v;
            }
        }
        prevV = v;
    }
}