Que tipo de dados MySQL deve ser usado para Latitude / Longitude com 8 casas decimais?

Estou trabalhando com dados do mapa e o número Latitude/Longitudese estende para 8 casas decimais. Por exemplo:

Latitude 40.71727401
Longitude -74.00898606

Vi no documento do Google que usa:

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

no entanto, suas casas decimais só vão para 6.
Devo usar FLOAT(10, 8)ou existe outro método a considerar para armazenar esses dados para que sejam precisos. Será usado com os cálculos do mapa. Obrigado!

DECIMAL é o tipo de dados MySQL para aritmética exata. Ao contrário de FLOAT, sua precisão é fixa para qualquer tamanho de número; portanto, ao usá-lo em vez de FLOAT, você pode evitar erros de precisão ao fazer alguns cálculos. Se você estivesse apenas armazenando e recuperando os números sem cálculo, na prática o FLOAT seria seguro, embora não exista nenhum dano ao usar DECIMAL. Com os cálculos, o FLOAT ainda está ok, mas para ter certeza absoluta de 8d.p. precisão, você deve usar DECIMAL.

As latitudes variam de -90 a +90 (graus), então DECIMAL (10, 8) é bom para isso, mas as longitudes variam de -180 a +180 (graus), então você precisa de DECIMAL (11, 8). O primeiro número é o número total de dígitos armazenados e o segundo é o número após o ponto decimal.

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

Isso explica como o MySQL trabalha com tipos de dados de ponto flutuante.

ATUALIZAÇÃO: O MySQL suporta tipos de dados espaciais e Pointé um tipo de valor único que pode ser usado. Exemplo:

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

Além disso, você verá que os floatvalores são arredondados.

// por exemplo: valores fornecidos 41.0473112,29.0077011

flutuador (11,7) | decimal (11,7)
---------------------------
41.0473099 | 41.0473112
29.0077019 | 29.0077011

no laravel usado tipo de coluna decimal para migração

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

para obter mais informações, consulte o tipo de coluna disponível

Você pode definir seu tipo de dados como número inteiro assinado. Ao armazenar coordenadas no SQL, você pode definir como lat * 10000000 e long * 10000000. E ao selecionar com distância / raio, você dividirá as coordenadas de armazenamento em 10000000. Fiz o teste com 300K linhas, o tempo de resposta da consulta é bom. (CPU de 2 x 2,67 GHz, 2 GB de RAM, MySQL 5.5.49)

Não use float ... Ele arredondará suas coordenadas, resultando em algumas ocorrências estranhas.

Use decimal

O MySQL agora tem suporte para tipos de dados espaciais desde que essa pergunta foi feita. Portanto, a resposta atual aceita não está errada, mas se você estiver procurando por funcionalidades adicionais, como encontrar todos os pontos em um determinado polígono, use o tipo de dados POINT.

Confira os documentos do MySQL sobre tipos de dados geoespaciais e as funções de análise espacial

Eu acredito que a melhor maneira de armazenar Lat / Lng no MySQL é ter uma coluna POINT (tipo de dados 2D) com um índice 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));

Usando migrar ruby ​​nos trilhos

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

Código para usar / provar a precisão da resposta de Oğuzhan KURNUÇ .

RESUMO:
Ótima precisão (~ 1cm) em tamanho pequeno (4B).

A precisão é (muito próxima a) 7 dígitos decimais para valores acima do intervalo [-180, 180].
São 7 dígitos à direita do decimal (~ 1 cm) , para um total de 9 dígitos (ou 10 dígitos, se contar o "1" inicial de "180") próximo a -180.
Compare isso com uma flutuação de 4 bytes , que possui apenas ~ 7 dígitos no total, portanto, ~ 5 dígitos à direita do decimal próximo a + = 180 (~ 1m) .

Métodos para usar esta abordagem:

const double Fixed7Mult = 10000000;

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

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

Testes de precisão:

/// <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étodos auxiliares utilizados pelos testes:

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