How to group by each date with certain condition in postgresql? - postgresql

I have a table like this in postgresql. Each row shows a customer subscribed our products. For example, Customer 1 paid a 1 month subscription at 2019-07-03.
date product period subscriber_id units
2019-07-03 A 1Month 1 1
2019-07-02 A 1Year 2 1
2019-07-01 B 1Year 1 1
2019-06-30 B 1Month 3 1
2019-06-30 A 1Month 4 1
2019-06-03 B 1Month 4 1
2019-06-03 A 1Month 1 1
I want to calculate total valid different subscribers on each day, the result will look like
base_date product total_distinct_count
2019-07-03 A 3
2019-07-03 B 3
2019-07-02 A 3
2019-07-02 B 3
2019-07-01 A 2
2019-07-01 B 3
2019-06-30 A 2
2019-06-30 B 1
...
There are 3 different customers (1, 2, 4) who still subscribe product A at 2019-07-03 in first row.
I've tried to use groupby on each day and distinct count,
SELECT date, COUNT(DISTINCT(subscribers_id))
-- do some conditions
GROUP BY date, product
I don't know how to group by with this condition. If there is a better way to solve this problem. I will very appreciate !!!


This is pretty straightforward if you use date ranges.
CREATE TABLE SUBSCRIPTION (
date date,
product text,
period interval,
subscriber_id int,
units int
);
INSERT INTO SUBSCRIPTION VALUES
('2019-07-03', 'A' , '1 month', 1, 1),
('2019-07-02', 'A', '1 year', 2, 1),
('2019-07-01', 'B', '1 year', 1, 1),
('2019-06-30', 'B', '1 month', 3, 1),
('2019-06-30', 'A', '1 month', 4, 1),
('2019-06-03', 'B', '1 month', 4, 1),
('2019-06-03', 'A', '1 month', 1, 1);
-- First, get the list of dateranges, from 2019-06-03 to 2019-07-03 (or whatever you want)
WITH dates as (
SELECT daterange(t::date, (t + interval '1' day)::date, '[)')
FROM generate_series('2019-06-03'::timestamp without time zone,
'2019-07-03',
interval '1' day) as g(t)
)
SELECT lower(daterange)::date, count(distinct subscriber_id)
FROM dates
LEFT JOIN subscription ON daterange <#
daterange(subscription.date,
(subscription.date + period)::date)
GROUP BY daterange
;
lower | count
------------+-------
2019-06-03 | 2
2019-06-04 | 2
2019-06-05 | 2
2019-06-06 | 2
2019-06-07 | 2
2019-06-08 | 2
2019-06-09 | 2
2019-06-10 | 2
2019-06-11 | 2
2019-06-12 | 2
2019-06-13 | 2
2019-06-14 | 2
2019-06-15 | 2
2019-06-16 | 2
2019-06-17 | 2
2019-06-18 | 2
2019-06-19 | 2
2019-06-20 | 2
2019-06-21 | 2
2019-06-22 | 2
2019-06-23 | 2
2019-06-24 | 2
2019-06-25 | 2
2019-06-26 | 2
2019-06-27 | 2
2019-06-28 | 2
2019-06-29 | 2
2019-06-30 | 3
2019-07-01 | 3
2019-07-02 | 4
2019-07-03 | 4
(31 rows)
You could improve performance by storing (and indexing) the subscription valid time as a daterange instead of calculating it in the query.
EDIT: As Jay pointed out, I forgot to group by product:
WITH dates as (
SELECT daterange(t::date, (t + interval '1' day)::date, '[)')
FROM generate_series('2019-06-03'::timestamp without time zone,
'2019-07-03',
interval '1' day) as g(t)
)
SELECT lower(daterange)::date, product, count(distinct subscriber_id)
FROM dates
LEFT JOIN subscription ON daterange <#
daterange(subscription.date,
(subscription.date + period)::date)
GROUP BY daterange, product
;
lower | product | count
------------+---------+-------
2019-06-03 | A | 1
2019-06-03 | B | 1
2019-06-04 | A | 1
2019-06-04 | B | 1
2019-06-05 | A | 1
2019-06-05 | B | 1
2019-06-06 | A | 1
2019-06-06 | B | 1
2019-06-07 | A | 1
2019-06-07 | B | 1
2019-06-08 | A | 1
2019-06-08 | B | 1
2019-06-09 | A | 1
2019-06-09 | B | 1
2019-06-10 | A | 1
2019-06-10 | B | 1
2019-06-11 | A | 1
2019-06-11 | B | 1
2019-06-12 | A | 1
2019-06-12 | B | 1
2019-06-13 | A | 1
2019-06-13 | B | 1
2019-06-14 | A | 1
2019-06-14 | B | 1
2019-06-15 | A | 1
2019-06-15 | B | 1
2019-06-16 | A | 1
2019-06-16 | B | 1
2019-06-17 | A | 1
2019-06-17 | B | 1
2019-06-18 | A | 1
2019-06-18 | B | 1
2019-06-19 | A | 1
2019-06-19 | B | 1
2019-06-20 | A | 1
2019-06-20 | B | 1
2019-06-21 | A | 1
2019-06-21 | B | 1
2019-06-22 | A | 1
2019-06-22 | B | 1
2019-06-23 | A | 1
2019-06-23 | B | 1
2019-06-24 | A | 1
2019-06-24 | B | 1
2019-06-25 | A | 1
2019-06-25 | B | 1
2019-06-26 | A | 1
2019-06-26 | B | 1
2019-06-27 | A | 1
2019-06-27 | B | 1
2019-06-28 | A | 1
2019-06-28 | B | 1
2019-06-29 | A | 1
2019-06-29 | B | 1
2019-06-30 | A | 2
2019-06-30 | B | 2
2019-07-01 | A | 2
2019-07-01 | B | 3
2019-07-02 | A | 3
2019-07-02 | B | 3
2019-07-03 | A | 3
2019-07-03 | B | 2

Related

postgresql: query two tables with same column names and show the result side by side ordered their column names, which occur in both tables

Having two tables (table1, table2) with the same column names (generation, parent), the desired output would be the combination of all columns of both tables. Thereby the rows of table2 should join table1 so that the rows of table2 are matching those of table1 on generation column. The parent number should be ordered ascending for the entries in table1 as well as in table2. The number of rows of the query results should be equal of those of table1.
Given the following tables
table1:
| generation | parent |
|:----------:|:------:|
| 0 | 1 |
| 0 | 2 |
| 0 | 3 |
| 1 | 3 |
| 1 | 2 |
| 1 | 1 |
| 2 | 2 |
| 2 | 1 |
| 2 | 3 |
table2:
| generation | parent |
|:----------:|:------:|
| 1 | 3 |
| 1 | 1 |
| 1 | 3 |
| 2 | 1 |
| 2 | 2 |
| 2 | 3 |
The following queries are thought for creating and populating two sample tables as shown above:
create table table1(generation integer, parent integer);
insert into table1 (generation, parent) values(0,1),(0,2),(0,3),(1,3),(1,2),(1,1),(2,2),(2,1),(2,3);
create table table2(generation integer, parent integer);
insert into table2 (generation, parent) values(1,3),(1,1),(1,3),(2,1),(2,2),(2,3);
the imagined query should lead to the following desired result:
| table1_generation | table1_parent | table2_generation | table2_parent |
|:-----------------:|:-------------:|:-----------------:|:-------------:|
| 0 | 1 | | |
| 0 | 2 | | |
| 0 | 3 | | |
| 1 | 1 | 1 | 1 |
| 1 | 2 | 1 | 3 |
| 1 | 3 | 1 | 3 |
| 2 | 1 | 2 | 1 |
| 2 | 2 | 2 | 2 |
| 2 | 3 | 2 | 3 |
Current query looks as follows:
with
p as (
select
generation,
parent
from
table1
order by
generation,
parent
), o as(
select
generation,
parent
from
table2
order by
generation,
parent
)
select
p.generation as table1_generation,
p.parent as table1_parent,
o.generation as table2_generation,
o.parent as table2_parent
from
p
left join o on
o.generation=p.generation;
Which leads to the following result:
| table1_generation | table1_parent | table2_generation | table2_parent |
|:-----------------:|:-------------:|:-----------------:|:-------------:|
| 0 | 1 | | |
| 0 | 2 | | |
| 0 | 3 | | |
| 1 | 1 | 1 | 1 |
| 1 | 1 | 1 | 3 |
| 1 | 1 | 1 | 3 |
| 1 | 2 | 1 | 1 |
| 1 | 2 | 1 | 3 |
| 1 | 2 | 1 | 3 |
| 1 | 3 | 1 | 1 |
| 1 | 3 | 1 | 3 |
| 1 | 3 | 1 | 3 |
| 2 | 1 | 2 | 1 |
| 2 | 1 | 2 | 2 |
| 2 | 1 | 2 | 3 |
| 2 | 2 | 2 | 1 |
| 2 | 2 | 2 | 2 |
| 2 | 2 | 2 | 3 |
| 2 | 3 | 2 | 1 |
| 2 | 3 | 2 | 2 |
| 2 | 3 | 2 | 3 |
This link led to the conclusion, that any join command might not what is necessary here ... But union does only append rows... so for me it is absolutely unclear, how the desired result can be achieved o.O
Any help is highly appreciated. Thanks in advance!

The main misunderstanding on this question arose from the fact that you mentioned join, which is a very precisely mathematically defined concept based on the Cartesian product and can be applied to any two sets. So the current output is clear.
But as you wrote in the title, you want to put two tables side by side. You take advantage of the fact that they have the same number of rows (triples).
This select returns the output you want.
I made artificial join columns, row_number() OVER (order by generation, parent) as rnum, and moved the second table using the addition of three. I hope this helps you:
with
p as (
select
row_number() OVER (order by generation, parent) as rnum,
generation,
parent
from
table1
order by
generation,
parent
), o as(
select
row_number() OVER (order by generation, parent) as rnum,
generation,
parent
from
table2
order by
generation,
parent
)
select
p.generation as table1_generation,
p.parent as table1_parent,
o.generation as table2_generation,
o.parent as table2_parent
from
p
left join o on
o.rnum+3=p.rnum
order by 1,2,3,4;
Output:
table1_generation
table1_parent
table2_generation
table2_parent
0
1
(null)
(null)
0
2
(null)
(null)
0
3
(null)
(null)
1
1
1
1
1
2
1
3
1
3
1
3
2
1
2
1
2
2
2
2
2
3
2
3

PostgreSQL limit by group, only show first 2 store options

I need to select first 2 lines where the store_name is different than one given for a given product
id | store_name | prod_name
----+------------+------
1 | 1 | A
2 | 1 | B
3 | 1 | C
4 | 1 | A
5 | 2 | E
6 | 2 | A
7 | 3 | G
8 | 2 | A
9 | 1 | A
10 | 3 | A
(10 rows)
result should be store_name <> 3 AND prod_name ='A'
id | store_name | prod_name
----+------------+------
1 | 1 | A
4 | 1 | A
6 | 2 | A
8 | 2 | A

Use the row_number() window function to accomplish this.
Query #1
with first_two as (
select *,
row_number() over (partition by store_name
order by id) as rn
from store_product
where store_name <> 3
and prod_name = 'A'
)
select id, store_name, prod_name
from first_two
where rn <= 2;
| id | store_name | prod_name |
| --- | ---------- | --------- |
| 1 | 1 | A |
| 4 | 1 | A |
| 6 | 2 | A |
| 8 | 2 | A |
View on DB Fiddle

Cumulative sum of multiple window functions

I have a table with the structure:
id | date | player_id | score
--------------------------------------
1 | 2019-01-01 | 1 | 1
2 | 2019-01-02 | 1 | 1
3 | 2019-01-03 | 1 | 0
4 | 2019-01-04 | 1 | 0
5 | 2019-01-05 | 1 | 1
6 | 2019-01-06 | 1 | 1
7 | 2019-01-07 | 1 | 0
8 | 2019-01-08 | 1 | 1
9 | 2019-01-09 | 1 | 0
10 | 2019-01-10 | 1 | 0
11 | 2019-01-11 | 1 | 1
I want to create two more columns, 'total_score', 'last_seven_days'.
total_score is a rolling sum of the player_id score
last_seven_days is the score for the last seven days including to and prior to the date
I have written the following SQL query:
SELECT id,
date,
player_id,
score,
sum(score) OVER all_scores AS all_score,
sum(score) OVER last_seven AS last_seven_score
FROM scores
WINDOW all_scores AS (PARTITION BY player_id ORDER BY id ROWS BETWEEN UNBOUNDED PRECEDING AND 1 PRECEDING),
last_seven AS (PARTITION BY player_id ORDER BY id ROWS BETWEEN 7 PRECEDING AND 1 PRECEDING);
and get the following output:
id | date | player_id | score | all_score | last_seven_score
------------------------------------------------------------------
1 | 2019-01-01 | 1 | 1 | |
2 | 2019-01-02 | 1 | 1 | 1 | 1
3 | 2019-01-03 | 1 | 0 | 2 | 2
4 | 2019-01-04 | 1 | 0 | 2 | 2
5 | 2019-01-05 | 1 | 1 | 2 | 2
6 | 2019-01-06 | 1 | 1 | 3 | 3
7 | 2019-01-07 | 1 | 0 | 4 | 4
8 | 2019-01-08 | 1 | 1 | 4 | 4
9 | 2019-01-09 | 1 | 0 | 5 | 4
10 | 2019-01-10 | 1 | 0 | 5 | 3
11 | 2019-01-11 | 1 | 1 | 5 | 3
I have realised that I need to change this
last_seven AS (PARTITION BY player_id ORDER BY id ROWS BETWEEN 7 PRECEDING AND 1 PRECEDING)
to instead of being 7, to use some sort of date format because just having the number 7 will introduce errors.
i.e. it would be nice to be able to do date - 2days or date - 6days
I also would like to add columns such as 3 months, 6 months, 12 months later down the track and so need it to be able to be dynamic.
DEMO

demo:db<>fiddle
Solution for Postgres 11+:
Using RANGE interval as #LaurenzAlbe did
Solution for Postgres <11:
(just presenting the "days" part, the "all_scores" part is the same)
Joining the table against itself on the player_id and the relevant date range:
SELECT s1.*,
(SELECT SUM(s2.score)
FROM scores s2
WHERE s2.player_id = s1.player_id
AND s2."date" BETWEEN s1."date" - interval '7 days' AND s1."date" - interval '1 days')
FROM scores s1

You need to use a window by RANGE:
last_seven AS (PARTITION BY player_id
ORDER BY date
RANGE BETWEEN INTERVAL '7 days' PRECEDING
AND INTERVAL '1 day' PRECEDING)
This solution will work only from v11 on.

Rank based on row number SQL Server 2008 R2

I want to group rank my table data by rowcount. First 12 rows that are ordered by date for each ProductID would get value = 1. Next 12 rows would get value = 2 assigned and so on.
How table structure looks:
For ProductID = 1267 are below associated dates:
02-01-2016
03-01-2016
.
. (skipping months..table has one date per month)
.
12-01-2016
02-01-2017
.
.
.
02-01-2018

Use row_number() over() with some arithmetic to calculate groups of 12 ordered by date (per productid). Change the sort to ASCendng or DESCendng to suit your need.
select *
, (11 + row_number() over(partition by productid order by somedate DESC)) / 12 as rnk
from mytable
GO
myTableID | productid | somedate | rnk
--------: | :------------- | :------------------ | :--
9 | 123456 | 2018-11-12 08:24:25 | 1
8 | 123456 | 2018-10-02 12:29:04 | 1
7 | 123456 | 2018-09-09 02:39:30 | 1
2 | 123456 | 2018-09-02 08:49:37 | 1
1 | 123456 | 2018-07-04 12:25:06 | 1
5 | 123456 | 2018-06-06 11:38:50 | 1
12 | 123456 | 2018-05-23 21:12:03 | 1
18 | 123456 | 2018-04-02 03:59:16 | 1
3 | 123456 | 2018-01-02 03:42:24 | 1
17 | 123456 | 2017-11-29 03:19:32 | 1
10 | 123456 | 2017-11-10 00:45:41 | 1
13 | 123456 | 2017-11-05 09:53:38 | 1
16 | 123456 | 2017-10-20 15:39:42 | 2
4 | 123456 | 2017-10-14 19:25:30 | 2
20 | 123456 | 2017-09-21 21:31:06 | 2
6 | 123456 | 2017-04-06 22:10:58 | 2
14 | 123456 | 2017-03-24 23:35:52 | 2
19 | 123456 | 2017-01-22 05:07:23 | 2
11 | 123456 | 2016-12-13 19:17:08 | 2
15 | 123456 | 2016-12-02 03:22:32 | 2
dbfiddle here

Postgresql: Select sum with different conditions

I have two table table:
I. Table 1 like this:
------------------------------------------
codeid | pos | neg | category
-----------------------------------------
1 | 10 | 3 | begin2016
1 | 3 | 5 | justhere
3 | 7 | 7 | justthere
4 | 1 | 1 | else
4 | 12 | 0 | begin2015
4 | 5 | 12 | begin2013
1 | 2 | 50 | now
2 | 5 | 33 | now
5 | 33 | 0 | Begin2011
5 | 11 | 7 | begin2000
II. Table 2 like this:
------------------------------------------
codeid | codedesc | codegroupid
-----------------------------------------
1 | road runner | 1
2 | bike warrior | 2
3 | lazy driver | 4
4 | clever runner | 1
5 | worker | 3
6 | smarty | 1
7 | sweety | 3
8 | sweeper | 1
I want to have one result like this having two (or more) conditions:
sum pos and neg where codegroupid IN('1', '2', '3')
BUt do not sum pos and neg if category like 'begin%'
So the result will like this:
------------------------------------------
codeid | codedesc | sumpos | sumneg
-----------------------------------------
1 | roadrunner | 5 | 55 => (sumpos = 3+2, because 10 have category like 'begin%' so doesn't sum)
2 | bike warrior | 5 | 33
4 | clever runner | 1 | 1
5 | worker | 0 | 0 => (sumpos=sumneg=0) becase codeid 5 category ilike 'begin%'
Group by codeid, codedesc;
Sumpos is sum(pos) where category NOT ILIKE 'begin%', BUT IF category ILKIE 'begin%' make all pos values become zero (0);
Sumpos is sum(neg) where category NOT ILIKE 'begin%', BUT IF category ILKIE 'begin%' make all neg values become zero;
Any ideas how to do it?

Try:
SELECT
b.codeid,
b.codedesc,
sum(CASE WHEN category LIKE 'begin%' THEN 0 ELSE a.pos END) AS sumpos,
sum(CASE WHEN category LIKE 'begin%' THEN 0 ELSE a.neg END) AS sumneg
FROM
table1 AS a
JOIN
table2 AS b ON a.codeid = b.codeid
WHERE b.codegroupid IN (1, 2, 3)
GROUP BY
b.codeid,
b.codedesc;