Mở rộng đối tượng JSON cấp cao nhất thành một tập hợp các cặp khóa/giá trị
a | b | c
---+-----------+-------------
1 | {2,"a b"} | [4,"a b c"]
0 →key | value -----+------- a | "foo" b | "bar"
a | b | c
---+-----------+-------------
1 | {2,"a b"} | [4,"a b c"]
1 [ value ----------- foo bar2 ] →
key | value -----+------- a | foo b | bar8 [
key | value -----+------- a | foo b | bar9
key | value -----+------- a | "foo" b | "bar"4,
json_object_keys ------------------ f1 f21
key | value -----+------- a | "foo" b | "bar"4 ]
a | b | c
---+-----------+-------------
1 | {2,"a b"} | [4,"a b c"]
8 [ value ----------- foo bar5 ] →
key | value -----+------- a | foo b | bar8 [
key | value -----+------- a | foo b | bar9
key | value -----+------- a | "foo" b | "bar"4,
json_object_keys ------------------ f1 f21
key | value -----+------- a | "foo" b | "bar"4 ]
Mở rộng đối tượng JSON cấp cao nhất thành một tập hợp các cặp khóa/giá trị. Các
json_object_keys ------------------ f1 f21 được trả về sẽ thuộc loại
key | value -----+------- a | "foo" b | "bar"4
a | b ---+--- 1 | 2 3 | 47 →
key | value -----+------- a | foo b | bar
a | b ---+--- 1 | 2 3 | 48 [
a | b ---+--- 1 | 2 3 | 49
value ----------- foo bar2,
a | b | c | d | r
---+---------+---------+---+---------------
1 | [1,2,3] | {1,2,3} | | [123,"a b c"]
1 a | b | c | d | r
---+---------+---------+---+---------------
1 | [1,2,3] | {1,2,3} | | [123,"a b c"]
2 a | b | c | d | r
---+---------+---------+---+---------------
1 | [1,2,3] | {1,2,3} | | [123,"a b c"]
3 ] → value ----------- foo bar2
a | b | c | d | r
---+---------+---------+---+---------------
1 | [1,2,3] | {1,2,3} | | [123,"a b c"]
5 [ a | b ---+--- 1 | 2 3 | 49
value ----------- foo bar5,
a | b | c | d | r
---+---------+---------+---+---------------
1 | [1,2,3] | {1,2,3} | | [123,"a b c"]
1 a | b | c | d | r
---+---------+---------+---+---------------
1 | [1,2,3] | {1,2,3} | | [123,"a b c"]
2 a | b | c | d | r
---+---------+---------+---+---------------
1 | [1,2,3] | {1,2,3} | | [123,"a b c"]
3 ] → value ----------- foo bar5
Trích xuất đối tượng con JSON tại đường dẫn đã chỉ định. [Điều này tương đương về mặt chức năng với toán tử
a | b ---+----- 1 | foo 2 |2, nhưng viết đường dẫn ra dưới dạng danh sách biến thiên có thể thuận tiện hơn trong một số trường hợp. ]
a | b ---+----- 1 | foo 2 |3 →
a | b ---+----- 1 | foo 2 |4
a | b ---+----- 1 | foo 2 |5 [
a | b ---+--- 1 | 2 3 | 49
value ----------- foo bar2,
a | b | c | d | r
---+---------+---------+---+---------------
1 | [1,2,3] | {1,2,3} | | [123,"a b c"]
1 a | b | c | d | r
---+---------+---------+---+---------------
1 | [1,2,3] | {1,2,3} | | [123,"a b c"]
2 a | b | c | d | r
---+---------+---------+---+---------------
1 | [1,2,3] | {1,2,3} | | [123,"a b c"]
3 ] → key | value -----+------- a | "foo" b | "bar"4
jsonb_path_query ------------------ 2 3 42 [
a | b ---+--- 1 | 2 3 | 49
value ----------- foo bar5,
a | b | c | d | r
---+---------+---------+---+---------------
1 | [1,2,3] | {1,2,3} | | [123,"a b c"]
1 a | b | c | d | r
---+---------+---------+---+---------------
1 | [1,2,3] | {1,2,3} | | [123,"a b c"]
2 a | b | c | d | r
---+---------+---------+---+---------------
1 | [1,2,3] | {1,2,3} | | [123,"a b c"]
3 ] → key | value -----+------- a | "foo" b | "bar"4
Trích xuất đối tượng con JSON tại đường dẫn đã chỉ định là
key | value -----+------- a | "foo" b | "bar"4. [Đây là chức năng tương đương với toán tử
value ----------- foo bar00. ]
value ----------- foo bar01 →
value ----------- foo bar02
value ----------- foo bar03 [
value ----------- foo bar2 ] →
key | value -----+------- a | "foo" b | "bar"0
value ----------- foo bar06 [
value ----------- foo bar5 ] →
key | value -----+------- a | "foo" b | "bar"0
Trả về bộ khóa trong đối tượng JSON cấp cao nhất
value ----------- foo bar09 →
json_object_keys ------------------ f1 f2
value ----------- foo bar10 [
value ----------- foo bar11
value ----------- foo bar12,
a | b ---+--- 1 | 2 3 | 49
value ----------- foo bar2 ] →
value ----------- foo bar12
value ----------- foo bar16 [
value ----------- foo bar11
value ----------- foo bar12,
a | b ---+--- 1 | 2 3 | 49
value ----------- foo bar5 ] →
value ----------- foo bar12
Mở rộng đối tượng JSON cấp cao nhất thành một hàng có kiểu tổng hợp của đối số
value ----------- foo bar11. Đối tượng JSON được quét để tìm các trường có tên khớp với tên cột của loại hàng đầu ra và các giá trị của chúng được chèn vào các cột đó của đầu ra. [Các trường không tương ứng với bất kỳ tên cột đầu ra nào sẽ bị bỏ qua. ] Trong cách sử dụng thông thường, giá trị của
value ----------- foo bar11 chỉ là
value ----------- foo bar24, có nghĩa là bất kỳ cột đầu ra nào không khớp với bất kỳ trường đối tượng nào sẽ được điền bằng giá trị rỗng. Tuy nhiên, nếu
value ----------- foo bar11 không phải là
value ----------- foo bar24 thì các giá trị chứa trong đó sẽ được sử dụng cho các cột không khớp
Để chuyển đổi giá trị JSON thành loại SQL của cột đầu ra, các quy tắc sau được áp dụng theo trình tự
Giá trị null JSON được chuyển đổi thành SQL null trong mọi trường hợp
Nếu cột đầu ra thuộc loại
value ----------- foo bar
2 hoặcvalue ----------- foo bar
5, thì giá trị JSON chỉ được sao chép chính xácNếu cột đầu ra là một loại [hàng] tổng hợp và giá trị JSON là một đối tượng JSON, thì các trường của đối tượng được chuyển đổi thành các cột của loại hàng đầu ra bằng cách áp dụng đệ quy các quy tắc này
Tương tự như vậy, nếu cột đầu ra là một kiểu mảng và giá trị JSON là một mảng JSON, thì các phần tử của mảng JSON được chuyển đổi thành các phần tử của mảng đầu ra bằng ứng dụng đệ quy của các quy tắc này
Mặt khác, nếu giá trị JSON là một chuỗi, thì nội dung của chuỗi sẽ được đưa vào hàm chuyển đổi đầu vào cho kiểu dữ liệu của cột
Mặt khác, biểu diễn văn bản thông thường của giá trị JSON được cung cấp cho hàm chuyển đổi đầu vào cho kiểu dữ liệu của cột
Mặc dù ví dụ bên dưới sử dụng giá trị JSON không đổi, nhưng cách sử dụng thông thường sẽ là tham chiếu cột
value ----------- foo bar2 hoặc
value ----------- foo bar5 từ một bảng khác trong mệnh đề
value ----------- foo bar31 của truy vấn. Viết
value ----------- foo bar10 trong mệnh đề
value ----------- foo bar31 là một cách thực hành tốt, vì tất cả các cột được trích xuất đều có sẵn để sử dụng mà không cần gọi hàm trùng lặp
value ----------- foo bar34
value ----------- foo bar35
value ----------- foo bar36 →
a | b | c
---+-----------+-------------
1 | {2,"a b"} | [4,"a b c"]
value ----------- foo bar37 [
value ----------- foo bar11
value ----------- foo bar12,
a | b ---+--- 1 | 2 3 | 49
value ----------- foo bar2 ] →
value ----------- foo bar42
value ----------- foo bar43 [
value ----------- foo bar11
value ----------- foo bar12,
a | b ---+--- 1 | 2 3 | 49
value ----------- foo bar5 ] →
value ----------- foo bar42
Mở rộng mảng đối tượng JSON cấp cao nhất thành một tập hợp các hàng có kiểu tổng hợp của đối số
value ----------- foo bar11. Mỗi phần tử của mảng JSON được xử lý như mô tả ở trên cho
value ----------- foo bar50
value ----------- foo bar51
value ----------- foo bar52 →
a | b ---+--- 1 | 2 3 | 4
value ----------- foo bar53 [
value ----------- foo bar2 ] →
value ----------- foo bar55
value ----------- foo bar56 [
value ----------- foo bar5 ] →
value ----------- foo bar55
Mở rộng đối tượng JSON cấp cao nhất thành một hàng có loại hỗn hợp được xác định bởi mệnh đề
value ----------- foo bar59. [Như với tất cả các hàm trả về
value ----------- foo bar55, truy vấn gọi phải xác định rõ ràng cấu trúc của bản ghi bằng mệnh đề
value ----------- foo bar59. ] Bản ghi đầu ra được điền từ các trường của đối tượng JSON, giống như cách được mô tả ở trên cho
value ----------- foo bar50. Vì không có giá trị bản ghi đầu vào, các cột không khớp luôn chứa đầy giá trị rỗng
value ----------- foo bar63
value ----------- foo bar64 →
a | b | c | d | r
---+---------+---------+---+---------------
1 | [1,2,3] | {1,2,3} | | [123,"a b c"]
value ----------- foo bar65 [
value ----------- foo bar2 ] →
key | value -----+------- a | foo b | bar8
value ----------- foo bar68 [
value ----------- foo bar5 ] →
key | value -----+------- a | foo b | bar8
Mở rộng mảng đối tượng JSON cấp cao nhất thành một tập hợp các hàng có loại hỗn hợp được xác định bởi mệnh đề
value ----------- foo bar59. [Như với tất cả các hàm trả về
value ----------- foo bar55, truy vấn gọi phải xác định rõ ràng cấu trúc của bản ghi bằng mệnh đề
value ----------- foo bar59. ] Mỗi phần tử của mảng JSON được xử lý như mô tả ở trên cho
value ----------- foo bar50
value ----------- foo bar75 →
a | b ---+----- 1 | foo 2 |
value ----------- foo bar76 [
value ----------- foo bar77
value ----------- foo bar5,
value ----------- foo bar79
a | b | c | d | r
---+---------+---------+---+---------------
1 | [1,2,3] | {1,2,3} | | [123,"a b c"]
3, value ----------- foo bar81
value ----------- foo bar5 [,
value ----------- foo bar83
value ----------- foo bar84 ] ] →
value ----------- foo bar5
Trả về
value ----------- foo bar77 với mục được chỉ định bởi
value ----------- foo bar79 được thay thế bằng
value ----------- foo bar81 hoặc thêm
value ----------- foo bar81 nếu
value ----------- foo bar83 là đúng [là mặc định] và mục được chỉ định bởi
value ----------- foo bar79 không tồn tại. Tất cả các bước trước đó trong đường dẫn phải tồn tại hoặc
value ----------- foo bar77 được trả về không thay đổi. Cũng giống như các toán tử hướng đường dẫn, các số nguyên âm xuất hiện trong
value ----------- foo bar79 được tính từ cuối mảng JSON. Nếu bước đường dẫn cuối cùng là một chỉ mục mảng nằm ngoài phạm vi và
value ----------- foo bar83 là đúng, giá trị mới sẽ được thêm vào đầu mảng nếu chỉ mục là âm hoặc ở cuối mảng nếu nó là dương
value ----------- foo bar95 →
value ----------- foo bar96
value ----------- foo bar97 →
value ----------- foo bar98
value ----------- foo bar99 [
value ----------- foo bar77
value ----------- foo bar5,
value ----------- foo bar79
a | b | c | d | r
---+---------+---------+---+---------------
1 | [1,2,3] | {1,2,3} | | [123,"a b c"]
3, value ----------- foo bar81
value ----------- foo bar5 [,
value ----------- foo bar83
value ----------- foo bar84 [,
key | value -----+------- a | "foo" b | "bar"08
key | value -----+------- a | "foo" b | "bar"4 ]] ] →
value ----------- foo bar5
Nếu
value ----------- foo bar81 không phải là
value ----------- foo bar24, hành xử giống hệt với
value ----------- foo bar76. Mặt khác, hành xử theo giá trị của
key | value -----+------- a | "foo" b | "bar"08 phải là một trong số
key | value -----+------- a | "foo" b | "bar"15,
key | value -----+------- a | "foo" b | "bar"16,
key | value -----+------- a | "foo" b | "bar"17 hoặc
key | value -----+------- a | "foo" b | "bar"18. Mặc định là
key | value -----+------- a | "foo" b | "bar"16
key | value -----+------- a | "foo" b | "bar"20 →
key | value -----+------- a | "foo" b | "bar"21
key | value -----+------- a | "foo" b | "bar"22 →
key | value -----+------- a | "foo" b | "bar"23
key | value -----+------- a | "foo" b | "bar"24 [
value ----------- foo bar77
value ----------- foo bar5,
value ----------- foo bar79
a | b | c | d | r
---+---------+---------+---+---------------
1 | [1,2,3] | {1,2,3} | | [123,"a b c"]
3, value ----------- foo bar81
value ----------- foo bar5 [,
key | value -----+------- a | "foo" b | "bar"31
value ----------- foo bar84 ] ] →
value ----------- foo bar5
Trả về
value ----------- foo bar77 với
value ----------- foo bar81 được chèn vào. Nếu mục được chỉ định bởi
value ----------- foo bar79 là một phần tử mảng, thì
value ----------- foo bar81 sẽ được chèn vào trước mục đó nếu
key | value -----+------- a | "foo" b | "bar"31 là sai [là giá trị mặc định] hoặc sau mục đó nếu
key | value -----+------- a | "foo" b | "bar"31 là đúng. Nếu mục được chỉ định bởi
value ----------- foo bar79 là một trường đối tượng, thì
value ----------- foo bar81 sẽ chỉ được chèn nếu đối tượng chưa chứa khóa đó. Tất cả các bước trước đó trong đường dẫn phải tồn tại hoặc
value ----------- foo bar77 được trả về không thay đổi. Cũng giống như các toán tử hướng đường dẫn, các số nguyên âm xuất hiện trong
value ----------- foo bar79 được tính từ cuối mảng JSON. Nếu bước đường dẫn cuối cùng là một chỉ mục mảng nằm ngoài phạm vi, thì giá trị mới sẽ được thêm vào đầu mảng nếu chỉ mục là âm hoặc ở cuối mảng nếu chỉ mục đó là dương
key | value -----+------- a | "foo" b | "bar"44 →
key | value -----+------- a | "foo" b | "bar"45
key | value -----+------- a | "foo" b | "bar"46 →
key | value -----+------- a | "foo" b | "bar"47
key | value -----+------- a | "foo" b | "bar"48 [
value ----------- foo bar2 ] →
value ----------- foo bar2
key | value -----+------- a | "foo" b | "bar"51 [
value ----------- foo bar5 ] →
value ----------- foo bar5
Xóa tất cả các trường đối tượng có giá trị null khỏi giá trị JSON đã cho, theo cách đệ quy. Các giá trị null không phải là trường đối tượng sẽ không bị ảnh hưởng
key | value -----+------- a | "foo" b | "bar"54 →
key | value -----+------- a | "foo" b | "bar"55
key | value -----+------- a | "foo" b | "bar"56 [
value ----------- foo bar77
value ----------- foo bar5,
value ----------- foo bar79
key | value -----+------- a | "foo" b | "bar"60 [,
key | value -----+------- a | "foo" b | "bar"61
value ----------- foo bar5 [,
key | value -----+------- a | "foo" b | "bar"63
value ----------- foo bar84 ]] ] →
value ----------- foo bar84
Kiểm tra xem đường dẫn JSON có trả về bất kỳ mục nào cho giá trị JSON được chỉ định hay không. Nếu đối số
key | value -----+------- a | "foo" b | "bar"61 được chỉ định, nó phải là một đối tượng JSON và các trường của nó cung cấp các giá trị được đặt tên để được thay thế vào biểu thức
key | value -----+------- a | "foo" b | "bar"60. Nếu đối số
key | value -----+------- a | "foo" b | "bar"63 được chỉ định và là
key | value -----+------- a | "foo" b | "bar"69, hàm sẽ loại bỏ các lỗi tương tự như các toán tử
key | value -----+------- a | "foo" b | "bar"70 và
key | value -----+------- a | "foo" b | "bar"71 thực hiện
key | value -----+------- a | "foo" b | "bar"72 →
key | value -----+------- a | "foo" b | "bar"73
key | value -----+------- a | "foo" b | "bar"74 [
value ----------- foo bar77
value ----------- foo bar5,
value ----------- foo bar79
key | value -----+------- a | "foo" b | "bar"60 [,
key | value -----+------- a | "foo" b | "bar"61
value ----------- foo bar5 [,
key | value -----+------- a | "foo" b | "bar"63
value ----------- foo bar84 ]] ] →
value ----------- foo bar84
Trả về kết quả kiểm tra vị từ đường dẫn JSON cho giá trị JSON đã chỉ định. Chỉ mục đầu tiên của kết quả được tính đến. Nếu kết quả không phải là Boolean, thì trả về
value ----------- foo bar24. Các đối số tùy chọn
key | value -----+------- a | "foo" b | "bar"61 và
key | value -----+------- a | "foo" b | "bar"63 hoạt động tương tự như đối với
key | value -----+------- a | "foo" b | "bar"56
key | value -----+------- a | "foo" b | "bar"88 →
key | value -----+------- a | "foo" b | "bar"73
key | value -----+------- a | "foo" b | "bar"90 [
value ----------- foo bar77
value ----------- foo bar5,
value ----------- foo bar79
key | value -----+------- a | "foo" b | "bar"60 [,
key | value -----+------- a | "foo" b | "bar"61
value ----------- foo bar5 [,
key | value -----+------- a | "foo" b | "bar"63
value ----------- foo bar84 ]] ] →
value ----------- foo bar6
Trả về tất cả các mục JSON do đường dẫn JSON trả về cho giá trị JSON đã chỉ định. Các đối số tùy chọn
key | value -----+------- a | "foo" b | "bar"61 và
key | value -----+------- a | "foo" b | "bar"63 hoạt động tương tự như đối với
key | value -----+------- a | "foo" b | "bar"56
key | value -----+------- a | foo b | bar03 →
jsonb_path_query ------------------ 2 3 4
key | value -----+------- a | foo b | bar04 [
value ----------- foo bar77
value ----------- foo bar5,
value ----------- foo bar79
key | value -----+------- a | "foo" b | "bar"60 [,
key | value -----+------- a | "foo" b | "bar"61
value ----------- foo bar5 [,
key | value -----+------- a | "foo" b | "bar"63
value ----------- foo bar84 ]] ] →
value ----------- foo bar5
Trả về tất cả các mục JSON do đường dẫn JSON trả về cho giá trị JSON đã chỉ định, dưới dạng một mảng JSON. Các đối số tùy chọn
key | value -----+------- a | "foo" b | "bar"61 và
key | value -----+------- a | "foo" b | "bar"63 hoạt động tương tự như đối với
key | value -----+------- a | "foo" b | "bar"56
key | value -----+------- a | foo b | bar17 →
key | value -----+------- a | foo b | bar18
key | value -----+------- a | foo b | bar19 [
value ----------- foo bar77
value ----------- foo bar5,
value ----------- foo bar79
key | value -----+------- a | "foo" b | "bar"60 [,
key | value -----+------- a | "foo" b | "bar"61
value ----------- foo bar5 [,
key | value -----+------- a | "foo" b | "bar"63
value ----------- foo bar84 ]] ] →
value ----------- foo bar5
Trả về mục JSON đầu tiên được trả về bởi đường dẫn JSON cho giá trị JSON được chỉ định. Trả về
value ----------- foo bar24 nếu không có kết quả. Các đối số tùy chọn
key | value -----+------- a | "foo" b | "bar"61 và
key | value -----+------- a | "foo" b | "bar"63 hoạt động tương tự như đối với
key | value -----+------- a | "foo" b | "bar"56
key | value -----+------- a | foo b | bar33 →
key | value -----+------- a | foo b | bar34
key | value -----+------- a | foo b | bar35 [
value ----------- foo bar77
value ----------- foo bar5,
value ----------- foo bar79
key | value -----+------- a | "foo" b | "bar"60 [,
key | value -----+------- a | "foo" b | "bar"61
value ----------- foo bar5 [,
key | value -----+------- a | "foo" b | "bar"63
value ----------- foo bar84 ]] ] →
value ----------- foo bar84
key | value -----+------- a | foo b | bar45 [
value ----------- foo bar77
value ----------- foo bar5,
value ----------- foo bar79
key | value -----+------- a | "foo" b | "bar"60 [,
key | value -----+------- a | "foo" b | "bar"61
value ----------- foo bar5 [,
key | value -----+------- a | "foo" b | "bar"63
value ----------- foo bar84 ]] ] →
value ----------- foo bar84
key | value -----+------- a | foo b | bar55 [
value ----------- foo bar77
value ----------- foo bar5,
value ----------- foo bar79
key | value -----+------- a | "foo" b | "bar"60 [,
key | value -----+------- a | "foo" b | "bar"61
value ----------- foo bar5 [,
key | value -----+------- a | "foo" b | "bar"63
value ----------- foo bar84 ]] ] →
value ----------- foo bar6
key | value -----+------- a | foo b | bar65 [
value ----------- foo bar77
value ----------- foo bar5,
value ----------- foo bar79
key | value -----+------- a | "foo" b | "bar"60 [,
key | value -----+------- a | "foo" b | "bar"61
value ----------- foo bar5 [,
key | value -----+------- a | "foo" b | "bar"63
value ----------- foo bar84 ]] ] →
value ----------- foo bar5
key | value -----+------- a | foo b | bar75 [
value ----------- foo bar77
value ----------- foo bar5,
value ----------- foo bar79
key | value -----+------- a | "foo" b | "bar"60 [,
key | value -----+------- a | "foo" b | "bar"61
value ----------- foo bar5 [,
key | value -----+------- a | "foo" b | "bar"63
value ----------- foo bar84 ]] ] →
value ----------- foo bar5
Các hàm này hoạt động giống như các đối tác của chúng được mô tả ở trên mà không có hậu tố
key | value -----+------- a | foo b | bar85, ngoại trừ việc các hàm này hỗ trợ so sánh các giá trị ngày/giờ yêu cầu chuyển đổi theo múi giờ. Ví dụ bên dưới yêu cầu diễn giải giá trị chỉ ngày
key | value -----+------- a | foo b | bar86 dưới dạng dấu thời gian có múi giờ, vì vậy kết quả phụ thuộc vào cài đặt hiện tại. Do sự phụ thuộc này, các chức năng này được đánh dấu là ổn định, có nghĩa là các chức năng này không thể được sử dụng trong các chỉ mục. Các bản sao của chúng là bất biến và do đó có thể được sử dụng trong các chỉ mục;
key | value -----+------- a | foo b | bar87 →
key | value -----+------- a | "foo" b | "bar"73
key | value -----+------- a | foo b | bar89 [
value ----------- foo bar5 ] →
key | value -----+------- a | "foo" b | "bar"4
Chuyển đổi giá trị JSON đã cho thành văn bản thụt lề, được in đẹp
key | value -----+------- a | foo b | bar92 →
value ----------- foo bar0
key | value -----+------- a | foo b | bar93 [
value ----------- foo bar2 ] →
key | value -----+------- a | "foo" b | "bar"4
key | value -----+------- a | foo b | bar96 [
value ----------- foo bar5 ] →
key | value -----+------- a | "foo" b | "bar"4
Trả về loại giá trị JSON cấp cao nhất dưới dạng chuỗi văn bản. Các loại có thể là
key | value -----+------- a | foo b | bar99,
json_object_keys ------------------ f1 f200,
json_object_keys ------------------ f1 f201,
json_object_keys ------------------ f1 f202,
value ----------- foo bar84 và
json_object_keys ------------------ f1 f204. [Không nên nhầm lẫn kết quả
json_object_keys ------------------ f1 f204 với SQL NULL; xem các ví dụ. ]