Loại dữ liệu MySQL nào nên được sử dụng cho Vĩ độ / Kinh độ với 8 chữ số thập phân?

Tôi đang làm việc với dữ liệu bản đồ và Latitude/Longitudemở rộng đến 8 vị trí thập phân. Ví dụ:

Latitude 40.71727401
Longitude -74.00898606

Tôi thấy trong tài liệu Google có sử dụng:

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

tuy nhiên, vị trí thập phân của chúng chỉ đến 6.
Tôi nên sử dụng FLOAT(10, 8)hoặc có phương pháp nào khác để xem xét việc lưu trữ dữ liệu này sao cho chính xác. Nó sẽ được sử dụng với các tính toán bản đồ. Cảm ơn!

DECIMAL là kiểu dữ liệu MySQL cho số học chính xác. Không giống như FLOAT, độ chính xác của nó được cố định cho bất kỳ kích thước số nào, do đó, bằng cách sử dụng nó thay vì FLOAT, bạn có thể tránh được các lỗi chính xác khi thực hiện một số tính toán. Nếu bạn chỉ lưu trữ và truy xuất các số mà không tính toán thì trong thực tế, FLOAT sẽ an toàn, mặc dù không có hại gì khi sử dụng DECIMAL. Với tính toán, FLOAT vẫn chủ yếu là ok, nhưng để chắc chắn về 8d.p. độ chính xác bạn nên sử dụng DECIMAL.

Vĩ độ nằm trong khoảng từ -90 đến +90 (độ), do đó, DECIMAL (10, 8) là ổn đối với điều đó, nhưng kinh độ nằm trong khoảng từ -180 đến +180 (độ) vì vậy bạn cần phải có QUYẾT ĐỊNH (11, 8). Số đầu tiên là tổng số chữ số được lưu trữ và số thứ hai là số sau dấu thập phân.

Nói ngắn gọn: lat DECIMAL(10, 8) NOT NULL, lng DECIMAL(11, 8) NOT NULL

Điều này giải thích cách MySQL hoạt động với các kiểu dữ liệu dấu phẩy động.

CẬP NHẬT: MySQL hỗ trợ các kiểu dữ liệu không gian và Pointlà loại giá trị đơn có thể được sử dụng. Thí dụ:

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

Ngoài ra, bạn sẽ thấy floatcác giá trị được làm tròn.

// ví dụ: các giá trị đã cho 41.0473112,29.0077011

phao (11,7) | số thập phân (11,7)
---------------------------
41.0473099 | 41.0473112
29.0077019 | 29.0077011

trong laravel sử dụng loại cột thập phân để di chuyển

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

để biết thêm thông tin xem loại cột có sẵn

Bạn có thể đặt kiểu dữ liệu của mình dưới dạng số nguyên đã ký. Khi bạn lưu trữ tọa độ thành SQL, bạn có thể đặt lat * 10000000 và dài * 10000000. Và khi bạn chọn với khoảng cách / bán kính, bạn sẽ chia tọa độ lưu trữ thành 10000000. Tôi đã kiểm tra nó với 300K hàng, thời gian phản hồi truy vấn là tốt. (CPU 2 x 2,67GHz, RAM 2 GB, MySQL 5,5,49)

Không sử dụng float ... Nó sẽ làm tròn tọa độ của bạn, dẫn đến một số sự cố lạ.

Sử dụng thập phân

MySQL hiện có hỗ trợ cho các loại dữ liệu không gian kể từ khi câu hỏi này được hỏi. Vì vậy, câu trả lời được chấp nhận hiện tại không sai, nhưng nếu bạn đang tìm kiếm chức năng bổ sung như tìm tất cả các điểm trong một đa giác đã cho thì hãy sử dụng kiểu dữ liệu POINT.

Kiểm tra Tài liệu Mysql về các loại dữ liệu không gian địa lý và các chức năng phân tích không gian

Tôi tin rằng cách tốt nhất để lưu trữ Lat / Lng trong MySQL là có một cột POINT (kiểu dữ liệu 2D) với chỉ mục 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));

Sử dụng ruby ​​di chuyển trên đường ray

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

Mã để sử dụng / chứng minh độ chính xác của câu trả lời của Oğuzhan KURNUÇ .

TÓM TẮT:
Độ chính xác tuyệt vời (~ 1cm) trong một kích thước nhỏ (4B).

Độ chính xác là (rất gần với) 7 chữ số thập phân cho các giá trị trong phạm vi [-180, 180].
Đó là 7 chữ số bên phải của số thập phân (~ 1cm) , với tổng số 9 chữ số (hoặc 10 chữ số, nếu tính "1" ban đầu của "180") gần + -180.
Tương phản điều này với một float 4 byte , chỉ có tổng số ~ 7 chữ số, vì vậy ~ 5 chữ số ở bên phải của số thập phân gần + = 180 (~ 1m) .

Phương pháp sử dụng phương pháp này:

const double Fixed7Mult = 10000000;

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

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

Kiểm tra độ chính xác:

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

Phương pháp trợ giúp được sử dụng bởi các bài kiểm tra:

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