SQL Thích/Chứa trên cột LỚN

Question

Tôi có cột BIGINT mà tôi muốn thực hiện đối sánh từng phần.

ví dụ: @search = 1 phải trả về tất cả các bản ghi trong đó số đầu tiên là 1 (1, 11, 100 v.v.). Về cơ bản giống như một Varchar LIKE.

Tôi đã thử:

DECLARE @search VARCHAR 
SET @search = '1' 

và

SET @search = '1%' 

Và sử dụng:

SELECT 
    id FROM table 
WHERE 
    CAST(id AS varchar) LIKE @search 

Thêm một %-@search không giúp. Bất kỳ ý tưởng làm thế nào để thực hiện điều này?

EDIT: nó có vẻ là biến. Nếu tôi mã cứng chuỗi trong mệnh đề WHERE tôi nhận được kết quả mà tôi đang tìm kiếm.

SELECT id FROM table WHERE CAST(id AS VARCHAR) LIKE '14%' 

này mang lại cho tôi tất cả hồ sơ với một id 14 * (14, 140, 1400 vv).

Answer 1

Hãy thử điều này thay vì:

DECLARE @search VARCHAR(10) 
SET @search = '1' 

SELECT id FROM table WHERE CAST(id AS VARCHAR(10)) LIKE @search + '%' 

Khi đúc để VARCHAR, bạn nên luôn luôn xác định độ dài. Nếu bạn không xác định độ dài, SQL-Server sẽ chỉ định một cho bạn. Đôi khi nó sẽ là 1 người khác, nó sẽ là 30. Đọc this để biết thêm thông tin.

Answer 2

này có thể giúp:

like 1% tương đương với: bất cứ điều gì lớn hơn hoặc bằng 10, nếu bạn đang so sánh số. Vì vậy, bạn có thể muốn làm tương tự như sau:

SELECT 
    id FROM table 
WHERE 
    id >= @search*10 --@Search is of course int 

Answer 3

Sự cố xảy ra với @search của bạn. Hãy thử như dưới đây thay vì

create table aaa (id bigint); 
insert into aaa values(1),(11),(100),(111),(1111),(2222); 

Chọn Query

SELECT 
    id FROM aaa 
WHERE 
    CAST(id AS varchar(1000)) LIKE '1%'; 

(OR) như dưới đây

DECLARE @search VARCHAR; 
SET @search = '1'; 

SELECT 
    id FROM aaa 
WHERE 
    CAST(id AS varchar(1000)) LIKE @search + '%'; 

Answer 4

Thay vì sử dụng các nhà điều hành LIKE thử sử dụng các chức năng LEFT. Điều này sẽ trả về phần bên trái của chuỗi ký tự với số ký tự được chỉ định.

SELECT id 
FROM table 
WHERE LEFT(CAST(id AS varchar), 1) = '1' 

Tôi không chắc chắn, nhưng tôi đã có giả định này là sẽ có hiệu suất tốt hơn so với sử dụng các nhà điều hành LIKE, đặc biệt là kể từ khi bạn biết bạn chỉ muốn so sánh với các nhân vật bắt đầu. Thường thì việc sử dụng hàm trong mệnh đề WHERE thường có thể gây ra hiệu suất kém do truy vấn không thể tận dụng bất kỳ chỉ mục nào có thể tồn tại trên cột. Tuy nhiên trong trường hợp này truy vấn gọi hàm CAST, vì vậy lợi ích của chỉ mục đã bị mất.

Chỉnh sửa: Nếu so sánh cần cho số chữ số thay đổi, thì bạn có thể sử dụng hàm LEN để xác định số ký tự cho hàm LEFT để trả về.

SELECT id 
FROM table 
WHERE LEFT(CAST(id AS varchar),LEN(@search)) = @search 

Answer 5

Không thích nhưng phải làm. Thay thế x bằng id.

WHERE 
(x >= 1000000000000000000 AND x < 2000000000000000000) OR 
(x >= 100000000000000000 AND x < 200000000000000000) OR 
(x >= 10000000000000000 AND x < 20000000000000000) OR 
(x >= 1000000000000000 AND x < 2000000000000000) OR 
(x >= 100000000000000 AND x < 200000000000000) OR 
(x >= 10000000000000 AND x < 20000000000000) OR 
(x >= 1000000000000 AND x < 2000000000000) OR 
(x >= 100000000000 AND x < 200000000000) OR 
(x >= 10000000000 AND x < 20000000000) OR 
(x >= 1000000000 AND x < 2000000000) OR 
(x >= 100000000 AND x < 200000000) OR 
(x >= 10000000 AND x < 20000000) OR 
(x >= 1000000 AND x < 2000000) OR 
(x >= 100000 AND x < 200000) OR 
(x >= 10000 AND x < 20000) OR 
(x >= 1000 AND x < 2000) OR 
(x >= 100 AND x < 200) OR 
(x >= 10 AND x < 20) OR 
(x = 1) 

Answer 6

Có cách để thực hiện việc này mà không cần chuyển đổi thành VARCHAR(30) - nhưng tôi đã không kiểm tra xem hiệu suất có thực sự tốt hơn hay không. LOG10() không phải là rẻ, nhưng phân chia số nguyên là. Vì vậy, thử nghiệm được bảo hành.

Given:

create table aaa (id bigint); 
insert into aaa values(1),(11),(100),(111),(1111),(2222),(1234),(4531),(1345134),(64513),(6451999123); 

declare @want int = 64 -- and these are your starting digits 

Toán học điên:

select id 
from dbo.aaa 
WHERE id/(CASE WHEN (LOG10(id) -CEILING(LOG10(@want))) > 1 
    THEN POWER(10 , CEILING(log10(id-1)-CEILING(LOG10(@want)))) 
    ELSE 1 END) = @want; 

Về cơ bản, các cặp LOG10() xác định số chữ số để chuyển ngay (thông qua phân chia số nguyên) để chỉ những số mong muốn của chữ số vẫn còn.