8 ondalık basamaklı Enlem / Boylam için hangi MySQL veri türü kullanılmalıdır?

Harita verileri ile çalışıyorum ve Latitude/Longitude8 ondalık basamağa kadar uzanıyor. Örneğin:

Latitude 40.71727401
Longitude -74.00898606

Şunu kullanan Google dokümanında gördüm :

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

ancak, ondalık basamakları yalnızca 6'ya gider. Bu verileri saklamam için başka bir yöntem
kullanmalı mıyım FLOAT(10, 8)yoksa bu yüzden de kesin. Harita hesaplamaları ile kullanılacaktır. Teşekkürler!

DECIMAL, kesin aritmetik için MySQL veri tipidir. FLOAT'ın aksine hassasiyeti herhangi bir sayı boyutu için sabittir, bu nedenle FLOAT yerine bunu kullanarak bazı hesaplamalar yaparken hassas hatalardan kaçınabilirsiniz. Sadece sayıları hesaplama yapmadan saklayıp alıyorsanız, pratikte DECIMAL kullanımında herhangi bir zarar olmamasına rağmen FLOAT güvenlidir. Hesaplamalar ile FLOAT hala çoğunlukla iyi, ama 8d.p'den kesinlikle emin olmak için. Hassasiyeti DECIMAL kullanmalısınız.

Enlemler -90 ila +90 (derece) arasında değişir, bu nedenle DECIMAL (10, 8) bunun için uygundur, ancak boylamlar -180 ila +180 (derece) arasında değişir, bu nedenle DECIMAL'a (11, 8) ihtiyacınız vardır. İlk sayı, saklanan toplam basamak sayısı ve ikincisi ondalık noktadan sonraki sayıdır.

Kısacası: lat DECIMAL(10, 8) NOT NULL, lng DECIMAL(11, 8) NOT NULL

Bu , MySQL'in kayan noktalı veri türleriyle nasıl çalıştığını açıklar.

GÜNCELLEME: MySQL, Mekansal veri türlerini destekler ve Pointkullanılabilen tek değerli bir türdür. Misal:

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

Ayrıca, floatdeğerlerin yuvarlandığını göreceksiniz .

// örneğin: verilen değerler 41.0473112,29.0077011

şamandıra (11,7) | ondalık (11,7)
---------------------------
41.0473099 | 41.0473112
29.0077019 | 29.0077011

laravel'de geçiş için ondalık sütun türü kullanıldı

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

daha fazla bilgi için kullanılabilir sütun türüne bakın

Veri türünüzü işaretli tam sayı olarak ayarlayabilirsiniz. SQL için koordinatları depoladığınızda lat * 10000000 ve long * 10000000 olarak ayarlayabilirsiniz. Ve mesafe / yarıçap ile seçtiğinizde, depolama koordinatlarını 10000000'e bölebilirsiniz. 300K satırlarla test ettim, sorgu yanıt süresi iyidir. (2 x 2.67GHz CPU, 2 GB RAM, MySQL 5.5.49)

Şamandıra kullanmayın ... Koordinatlarınızı yuvarlar ve bazı garip olaylara neden olur.

Ondalık kullan

MySQL artık bu soru sorulduğu için uzamsal veri türleri için desteğe sahip. Dolayısıyla, geçerli kabul edilen cevap yanlış değil, ancak belirli bir çokgen içindeki tüm noktaları bulmak gibi ek işlevler arıyorsanız, POINT veri türünü kullanın.

Mekansal veri türleri ve mekansal analiz fonksiyonları ile ilgili Mysql Dokümanlarına göz atın

MySQL Lat / Lng depolamak için en iyi yolu bir SPATIAL indeksi ile bir POINT sütun (2D veri türü) sahip olduğuna inanıyorum.

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

Raylar üzerinde migrate ruby ​​kullanma

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

Oğuzhan KURNUÇ'un cevabının doğruluğunu kullanma / kanıtlama kodu .

ÖZET:
Küçük boyutta (4B) büyük hassasiyet (~ 1 cm).

[-180, 180] aralıktaki değerler için kesinlik (çok yakın) 7 ondalık basamaktır.
De bu ondalık sağındaki 7 basamak (~ 1 cm) , 9 basamak toplam (ya da 10 haneli "180" bir "1" ilk sayımı kullanılırsa) + -180 yakın için.
Bunu, toplamda sadece ~ 7 basamaklı 4 baytlık bir kayan nokta ile kontrastlayın , bu nedenle ondalıktan sağda ~ 5 basamak + = 180 (~ 1m) yakınında .

Bu yaklaşımı kullanma yöntemleri:

const double Fixed7Mult = 10000000;

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

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

Hassasiyet testleri:

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

Testlerde kullanılan yardımcı yöntemler:

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