Welcher MySQL-Datentyp sollte für Latitude / Longitude mit 8 Dezimalstellen verwendet werden?

Ich arbeite mit Kartendaten und die Latitude/Longitudeerstreckt sich auf 8 Dezimalstellen. Beispielsweise:

Latitude 40.71727401
Longitude -74.00898606

Ich habe in dem Google-Dokument gesehen, das verwendet:

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

Ihre Dezimalstellen gehen jedoch nur auf 6.
Sollte ich eine FLOAT(10, 8)andere Methode verwenden, um diese Daten so zu speichern, dass sie präzise sind? Es wird mit Kartenberechnungen verwendet. Vielen Dank!

DECIMAL ist der MySQL-Datentyp für exakte Arithmetik. Im Gegensatz zu FLOAT ist die Genauigkeit für jede Zahlengröße festgelegt. Wenn Sie es also anstelle von FLOAT verwenden, können Sie bei einigen Berechnungen Präzisionsfehler vermeiden. Wenn Sie nur die Zahlen ohne Berechnung speichern und abrufen würden, wäre FLOAT in der Praxis sicher, obwohl die Verwendung von DECIMAL keinen Schaden anrichtet. Mit Berechnungen ist FLOAT meistens noch in Ordnung, aber um absolut sicher zu sein, 8d.p. Präzision sollten Sie DECIMAL verwenden.

Die Breiten reichen von -90 bis +90 (Grad), daher ist DECIMAL (10, 8) dafür in Ordnung, aber die Längen reichen von -180 bis +180 (Grad), sodass Sie DECIMAL (11, 8) benötigen. Die erste Zahl ist die Gesamtzahl der gespeicherten Ziffern und die zweite die Zahl nach dem Dezimalpunkt.

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

Dies erklärt, wie MySQL mit Gleitkomma-Datentypen funktioniert.

UPDATE: MySQL unterstützt räumliche Datentypen und Pointist ein einwertiger Typ, der verwendet werden kann. Beispiel:

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));

Außerdem sehen Sie, dass die floatWerte gerundet sind.

// zB: gegebene Werte 41.0473112,29.0077011

float (11,7) | dezimal (11,7)
---------------------------
41.0473099 | 41.0473112
29.0077019 | 29.0077011

In Laravel wird der Dezimalsäulentyp für die Migration verwendet

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

Weitere Informationen finden Sie unter verfügbarer Spaltentyp

Sie können Ihren Datentyp als vorzeichenbehaftete Ganzzahl festlegen. Wenn Sie Koordinaten für SQL speichern, können Sie lat * 10000000 und long * 10000000 festlegen. Und wenn Sie mit Abstand / Radius auswählen, teilen Sie die Speicherkoordinaten auf 10000000. Ich habe es mit 300K Zeilen getestet, die Antwortzeit für Abfragen ist gut. (2 x 2,67 GHz CPU, 2 GB RAM, MySQL 5.5.49)

Verwenden Sie kein Float ... Es rundet Ihre Koordinaten ab, was zu seltsamen Ereignissen führt.

Verwenden Sie eine Dezimalstelle

MySQL unterstützt jetzt räumliche Datentypen, seit diese Frage gestellt wurde. Die aktuell akzeptierte Antwort ist also nicht falsch. Wenn Sie jedoch nach zusätzlichen Funktionen suchen, z. B. nach allen Punkten innerhalb eines bestimmten Polygons, verwenden Sie den Datentyp POINT.

Überprüfen Sie die MySQL-Dokumente zu Geodatentypen und den räumlichen Analysefunktionen

Ich glaube, der beste Weg, Lat / Lng in MySQL zu speichern, besteht darin, eine POINT-Spalte (2D-Datentyp) mit einem SPATIAL-Index zu haben.

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));

Verwenden Sie Ruby auf Schienen migrieren

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 zur Verwendung / zum Nachweis der Genauigkeit der Antwort von Oğuzhan KURNUÇ .

ZUSAMMENFASSUNG:
Große Präzision (~ 1 cm) bei kleiner Größe (4B).

Die Genauigkeit beträgt (sehr nahe an) 7 Dezimalstellen für Werte über dem Bereich [-180, 180].
Das sind 7 Stellen rechts von der Dezimalstelle (~ 1 cm) , also insgesamt 9 Stellen (oder 10 Stellen, wenn die anfängliche "1" von "180" gezählt wird) in der Nähe von + -180.
Vergleichen Sie dies mit einem 4-Byte-Float , der insgesamt nur ~ 7 Stellen hat, also ~ 5 Stellen rechts von der Dezimalstelle in der Nähe von + = 180 (~ 1 m) .

Methoden zur Verwendung dieses Ansatzes:

const double Fixed7Mult = 10000000;

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

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

Präzisionstests:

/// <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}");
}

Hilfsmethoden für 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;
    }
}