I have a table like:
CREATE TABLE myrecord AS
id INT
other TEXT
attributes JSONB
The attributes are structured like this:
[
{"name": "a", "value": "1"},
{"name": "b", "value": "2"}
]
I'd like to convert that to a result like:
id INT, other TEXT, a TEXT, b TEXT
So that for a given row like
1 | "foo" | {..as above..}
I get a result like
1 | "foo" | "1" | "2"
Right now I'm able to unpack the attribute structure like this:
CREATE TYPE myrecord_attributes AS (name TEXT, value TEXT);
SELECT
id,
other,
(json_populate_recordset(NULL :: myrecord_attributes,
attributes :: JSON)).*
FROM myrecord
But with that I get results like:
1 | "foo" | "a" | "1"
1 | "foo" | "b" | "2"
How can I flatten the result from json_populate_recordset into the appropriate structure? I'm also open to alternate solutions which don't use it like that at all.
I'm using postgres 9.4 if that matters
You can do as this:
select m.id,
m.other,
x.value::jsonb->>'name' as name,
x.value::jsonb->>'value' as value
from myrecord m,
json_array_elements(m.attributes) x;
And if you like it to return the values with double quotes just change ->> to ->
See it working here: http://sqlfiddle.com/#!15/450cc/9
This is making use of the implicit LATERAL JOIN in Postgres 9.3 or later.
EDIT
My first solution did not meet the OP's requirements, so, I've created another solution:
select m.id,
m.other,
max(case when x.value::json->>'name' = 'a'
then x.value::json->>'value' else '' end) as a,
max(case when x.value::json->>'name' = 'b'
then x.value::json->>'value' else '' end) as b
from myrecord m,
json_array_elements(m.attributes) x
group by m.id,
m.other;
See it working here: http://sqlfiddle.com/#!15/450cc/14
Assuming that your jsonb array always has two elements as given in your question, you can explicitly select all required elements:
SELECT id, other, (attributes->0)->>'value' AS a, (attributes->1)->>'value' AS b
FROM myrecord;
Related
Consider the following JSON object,
[
{
"id": 5964460916832,
"name": "Size",
"value": "Small",
"position": 1,
"product_id": 4588516409440
},
{
"id": 5964460916833,
"name": "Size",
"value": "Medium",
"position": 2,
"product_id": 4588516409440
},
{
"id": 5964460916834,
"name": "Size",
"value": "Large",
"position": 3,
"product_id": 4588516409440
}
]
This is a value present in a table field called custom_attrs of JSON data type in a MySQL 8.0 table. I wanted to search the JSON data to match with multiple fields in the same object.
For example,
I wanted to see if there's a match for name "Size" and value "Medium" within the same object. It should not match the name in the first object and the value in the second object.
While we can always use JSON table, I don't prefer that due to the complexities it brings during the JOINs.
JSON_SEARCH supports LIKE operator, but it cannot ensure if it's from the same object
JSON_CONTAINS supports multiple fields but not LIKE as follows,
SET #doc = CAST('[{"id":5964460916832,"name":"Size","value":"Small","position":1,"product_id":4588516409440},{"id":5964460916833,"name":"Size","value":"Medium","position":2,"product_id":4588516409440},{"id":5964460916834,"name":"Size","value":"Large","position":3,"product_id":4588516409440}]' AS JSON);
SELECT JSON_CONTAINS(#doc, '{"name":"Size", "value":"Small"}')
Is there any way to get the same JSON_CONTAINS like functionality with partial search like, {"name":"Size", "value":"%sma%"}
Any help on this would be greatly helpful.
JSON_CONTAINS() only works with equality, not with pattern matching.
The JSON_TABLE() function is the solution intended to address the task you are trying to do. But you said you don't want to use it.
You can simulate JSON_TABLE() using other functions.
select * from (
select
json_unquote(json_extract(col, concat('$[',n.i,'].id'))) as `id`,
json_unquote(json_extract(col, concat('$[',n.i,'].name'))) as `name`,
json_unquote(json_extract(col, concat('$[',n.i,'].value'))) as `value`
from (select #doc as col) j
cross join (select 0 as i union select 1 union select 2 union select 3 union select 4 union select 5 ...) as n
) as t
where t.`id` is not null
order by id, `name`;
Output:
+---------------+------+--------+
| id | name | value |
+---------------+------+--------+
| 5964460916832 | Size | Small |
| 5964460916833 | Size | Medium |
| 5964460916834 | Size | Large |
+---------------+------+--------+
You could then easily add a condition like AND value LIKE '%sma%'.
As you can see, this query is even more complex than if you had used JSON_TABLE().
Really, any solution is going to be complex when you store your data in JSON format, then try to use SQL expressions and relational operations to query them as if they are normalized data. This is because you're practically implementing a mini-database within the functions of a real database. This is sometimes called the Inner-Platform Effect:
The inner-platform effect is the tendency of software architects to create a system so customizable as to become a replica, and often a poor replica, of the software development platform they are using. This is generally inefficient and such systems are often considered to be examples of an anti-pattern.
If you want simple queries, you should store data in normal rows and columns, not in JSON. Then you could get your result using quite ordinary SQL:
SELECT id, name, value FROM MyTable WHERE name = 'Size' AND value LIKE '%sma%';
I am inserting my data in a database with json_encoded. Now I want to search in "feature", but the result is not exactly true.
MySQL query:
select *
from `modul_69`
where `extmod` like '%"68":%'
and `extmod` like '%"4"%'
and `extmod` not like '%"4":%'
Results:
row1 data:
{"68":["1","4","7"],"67":["14"],"75":["28"]} - true
row2 data:
{"68":["59"],"67":["1","11","13"],"75":["3","4","5","27"]} - false
I want select only row1 by key:68 and value:4
Please help
Here is one way to do it using MySQL JSON functions, available since version 5.7:
select *
from t
where json_search(js -> '$."68"', 'one', '4') is not null
What this does is get the array that correspond to outer key '68' (using ->, which is a syntactic sugar for json_extract()), and then search its content with json_search(); if a non-null value is returned, we have a match.
To find if the value '"4"' is contained in the member '"68"', you can first extract the array using JSON_EXTRACT() :
SELECT JSON_EXTRACT(m.extmod, '$."68"')
FROM modul_69 m;
This outputs
["1", "4", "7"]
["59"]
To search in a JSON array if it contains a specific value, you can use JSON_CONTAINS() :
SELECT JSON_CONTAINS('["1", "4", "7"]', '"4"', '$'); -- output is 1
SELECT JSON_CONTAINS('["59"]', '"4"', '$'); -- output is 0
Now you can combine both functions to get the rows that contains the expected value :
Schema (MySQL v5.7)
CREATE TABLE modul_69
(
extmod JSON
);
INSERT INTO modul_69 VALUES ('{"68":["1","4","7"],"67":["14"],"75":["28"]}'), ('{"68":["59"],"67":["1","11","13"],"75":["3","4","5","27"]}');
Query #1
SELECT *
FROM modul_69 m
WHERE JSON_CONTAINS(JSON_EXTRACT(m.extmod, '$."68"'),
'"4"',
'$') = 1;
Output
| extmod |
| --------------------------------------------------- |
| {"67": ["14"], "68": ["1", "4", "7"], "75": ["28"]} |
View on DB Fiddle
I am trying to figure out in PostgreSQL 11 JSONB query
SELECT id, my_json_field #>> '{field_depth_1, field_depth_2}'
FROM my_data
WHERE my_json_field #> '{"other_field": 3}'::jsonb
If other_field is a key-value pair, this works perfectly and I get every row with other_field = 3. However, if other_field is a list of values, eg: [2,3,6,8,10], and I want to find out for every row whether the value 3 exists in the list represented by other_field, how should I write the query?
Use the operator #>. Per the documentation:
#> jsonb Does the left JSON value contain the right JSON path/value entries at the top level?
Example:
with my_data(id, my_json_field) as (
values
(1, '{"field_depth_1": {"field_depth_2": "something 1"}, "other_field": 3}'::jsonb),
(2, '{"field_depth_1": {"field_depth_2": "something 2"}, "other_field": 4}'),
(3, '{"field_depth_1": {"field_depth_2": "something 3"}, "other_field": [2,3,6,8,10]}'),
(4, '{"field_depth_1": {"field_depth_2": "something 4"}, "other_field": [2,4,6,8,10]}')
)
select id, my_json_field #>> '{field_depth_1, field_depth_2}' as value
from my_data
where my_json_field->'other_field' #> '3'
id | value
----+-------------
1 | something 1
3 | something 3
(2 rows)
I am going to convert my current PostgreSQL database into a MongoDB version. For example, I have a table to record tweets, and another table to record multiple hashtags used by a specific tweet. What I wanna do is to use SQL to get a table like below and then export it as a .csv file so that I could import it to MongoDB.
Example:
2018-04-02 18:12:32 This plane has no outlet for me to charge my p... [{'tag': 'GucciGarden', 'airline': 'American A...
The problem that I met is that I can get a .csv file contains json array like "[{'tag': 'GucciGarden', 'airline': 'American A...", but it is a String type! And when I import it into MongoDB. The quote will be kept, which makes sth wrong.
And here is my SQL code:
SELECT tweets.tweet_id,tweets.text,
(SELECT array_to_json(array_agg(row_to_json(d)))
from (
SELECT tags.tag
FROM
tags
WHERE tags.tweet_id=tweets.tweet_id
) d
) as Tags
from tweets
Here is the result that I import into MongoDB:
{
"_id" : ObjectId("5ac59c272221ade1185ec241"),
"tweet_id" : 9.80869021435351e+17.0,
"created_at" : "2018-04-02 18:06:13",
"text" : "RT #MiraSorvino: Brad Myles shares #Delta that awareness is working- 9,000 #humantrafficking cases identified by #polarisproject National H��",
"screen_name" : "MMexville",
"favorite_count" : 0.0,
"retweet_count" : 40.0,
"source" : "the public",
"tags" : "[{'tag': 'humantrafficking', 'airline': 'Delta Air Lines'}]"}
this is because [{'tag': is not a valid json - you should have used double quotes and cast to json, eg:
let's say smth like your sample:
t=# create table c (i int, t text, j text);
CREATE TABLE
t=# insert into c values(1,'text',$$[{'tag': 'GucciGarden'}]$$);
INSERT 0 1
t=# select * from c;
i | t | j
---+------+--------------------------
1 | text | [{'tag': 'GucciGarden'}]
(1 row)
so then smth like your qry:
t=# select to_json(c) from (select i,t,replace(j,$$'$$,'"')::json j from c) c;
to_json
-------------------------------------------------
{"i":1,"t":"text","j":[{"tag": "GucciGarden"}]}
(1 row)
of course you will have positive false replacements of single quotes, eg 'tag': 'Gucci's Garden' will break the query logic, so you will have to make a more sophisticated replacement. probably with regular expressions to be neater.
I have a table
key | value
-----+-------
a | "foo"
b | "bar"
How can I get the result
{"a": "foo", "b": "bar"}
It doesn't work with
select array_to_json(array_agg(t)) from table t; -- I get [{"key": "a", "value": "foo"}, {"key": "b", "value": "bar"}]
Can you help me?
PostgreSQL ≥ 9.4 :
SELECT json_object(array_agg(key), array_agg(value))
FROM t;
┌────────────────────────────┐
│ json_object │
├────────────────────────────┤
│ {"a" : "foo", "b" : "bar"} │
└────────────────────────────┘
(1 row)
If you are using PostgreSQL 9.4 you can use the following code to take key from one column and value from another and create a single JSON object:
select json_object(array_agg(key), array_agg(value)) from table;
For earlier versions I don't know of a simple method at this time.
For PostgreSQL 9.4+, there is an aggregate function specially for this:
SELECT json_object_agg(key, value)
FROM t
This avoids the cost of creating 2 PostgreSQL arrays.
For older PostgreSQL versions, you need to concatenate your result yourself:
SELECT concat('{', string_agg(to_json(key) || ':' || to_json(value), ','), '}')::json
FROM t
More details:
How do I modify fields inside the new PostgreSQL JSON datatype?