Jakiego typu danych MySQL należy użyć dla szerokości i długości geograficznej z 8 miejscami po przecinku?

Pracuję z danymi map i Latitude/Longitudeobejmuje 8 miejsc po przecinku. Na przykład:

Latitude 40.71727401
Longitude -74.00898606

Widziałem w dokumencie Google, który używa:

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

Jednak ich miejsca dziesiętne wynoszą tylko 6.
Powinienem użyć FLOAT(10, 8)lub istnieje inna metoda do rozważenia, aby przechowywać te dane, więc są one dokładne. Będzie używany z obliczeniami mapy. Dzięki!

DECIMAL to typ danych MySQL dla dokładnej arytmetyki. W przeciwieństwie do FLOAT, jego precyzja jest ustalona dla dowolnego rozmiaru liczby, więc używając go zamiast FLOAT można uniknąć błędów precyzji podczas wykonywania niektórych obliczeń. Jeśli tylko przechowywałeś i pobierałeś liczby bez obliczeń, w praktyce FLOAT byłby bezpieczny, chociaż korzystanie z DECIMAL nie szkodzi. Z obliczeń FLOAT nadal jest w większości w porządku, ale dla absolutnej pewności co do 8d.p. precyzji należy użyć DECIMAL.

Szerokość geograficzna wynosi od -90 do +90 (stopni), więc DECIMAL (10, 8) jest do tego odpowiedni, ale długości geograficzne wynoszą od -180 do +180 (stopni), więc potrzebujesz DECIMAL (11, 8). Pierwsza liczba to całkowita liczba zapisanych cyfr, a druga to liczba po przecinku.

W skrócie: lat DECIMAL(10, 8) NOT NULL, lng DECIMAL(11, 8) NOT NULL

To wyjaśnia, jak MySQL działa z zmiennoprzecinkowymi typami danych.

AKTUALIZACJA: MySQL obsługuje typy danych przestrzennych i Pointjest typem pojedynczej wartości, którego można używać. Przykład:

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

Dodatkowo zobaczysz, że floatwartości są zaokrąglone.

// np .: podane wartości 41.0473112,29.0077011

pływak (11,7) | dziesiętny (11,7)
---------------------------
41,0473099 | 41,0473112
29,0077019 | 29,0077011

w laravel wykorzystano dziesiętny typ kolumny do migracji

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

Aby uzyskać więcej informacji, zobacz dostępny typ kolumny

Możesz ustawić swój typ danych jako liczbę całkowitą ze znakiem. Podczas przechowywania współrzędnych do SQL można ustawić jako lat * 10000000 i długi * 10000000. A kiedy wybierasz z odległością / promieniem, podzielisz współrzędne miejsca przechowywania na 10000000. Przetestowałem to z 300 000 wierszy, czas odpowiedzi na zapytanie jest dobry. (2 x 2,67 GHz, 2 GB pamięci RAM, MySQL 5.5.49)

Nie używaj pływaka ... Zaokrągli twoje współrzędne, powodując dziwne zdarzenia.

Użyj dziesiętnego

MySQL obsługuje teraz typy danych przestrzennych od czasu zadania tego pytania. Tak więc bieżąca akceptowana odpowiedź nie jest zła, ale jeśli szukasz dodatkowej funkcjonalności, takiej jak znalezienie wszystkich punktów w danym wielokącie, użyj typu danych POINT.

Zapoznaj się z dokumentacją MySQL dotyczącą typów danych geoprzestrzennych i funkcji analizy przestrzennej

Uważam, że najlepszym sposobem przechowywania Lat / Lng w MySQL jest posiadanie kolumny POINT (typ danych 2D) z indeksem 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));

Korzystanie z migracji ruby ​​na szynach

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

Kod używający / potwierdzający precyzję odpowiedzi Oğuzhan KURNUÇ .

PODSUMOWANIE:
Wielka precyzja (~ 1 cm) w małym rozmiarze (4B).

Dokładność wynosi (bardzo blisko) 7 cyfr dziesiętnych dla wartości z zakresu [-180, 180].
To 7 cyfr na prawo od miejsca po przecinku (~ 1 cm) , w sumie 9 cyfr (lub 10 cyfr, licząc początkowe „1” z „180”) w pobliżu + -180.
Porównaj to z 4-bajtową liczbą zmiennoprzecinkową , która ma tylko ~ 7 cyfr łącznie, więc ~ 5 cyfr po prawej stronie dziesiętnej w pobliżu + = 180 (~ 1m) .

Metody zastosowania tego podejścia:

const double Fixed7Mult = 10000000;

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

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

Testy precyzji:

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

Metody pomocnicze stosowane w testach:

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