Timezone aware uniqueness constraint

user_5863438 0
Viewed 112

I am working with a timesheet app, used by users from multiple timezones. I am trying to introduce a unique constraint, that only allows users to clock_in or clock_out once per day in the local timezone.

Please refer to the following table declaration:

Table "public.entries"
---------------------------------------------
  Column   |              Type              |
---------------------------------------------
id         | bigint                         |
user_id    | bigint                         |
entry_type | string                         | enum(clock_in, clock_out)
created_at | timestamp(6) without time zone |

But little lost on how to handle the timezone-aware uniqueness.

Update:

  • I am considering 0:00 hrs to 23:55 hrs of local time zone as day.
  • User's timezone is stored in the users table but can move to the entries table if it helps with constraints.
postgresql sql
2 Answers

I misread the question and wrote a bad answer, so here's a new one...

I assume this is a typical client-server-db setup. You need to obtain the local time zone from the client that's clocking in/out the user; Postgres doesn't know what it is. We'll figure out the user's local date from that and store it. Then we'll have a uniqueness index on <user, local date>.

I thought there'd be fancier ways to do this by storing the timestamptz with a separate time zone col and calculating the date within the uniqueness index, but Postgres doesn't allow us to use date_trunc within an index. So we're going to denormalize just a little and make things a lot easier with this additional date col.

CREATE TABLE clock_in (
  user_id bigint NOT NULL,
  created_at timestamptz NOT NULL,  -- stores microseconds since epoch
  local_date date NOT NULL,  -- stores the <year, month, day> in whatever timezone the user clocked in from
  -- optional for bookkeeping purposes: time_zone text NOT NULL,
  UNIQUE(user_id, local_date)
);

Take a look at the official date/time type docs for further explanation of the above. IMO you shouldn't rely on DB constraints to reject bad user input. They're more of a second line of defense meant to ensure a self-consistent database. First your server should query the last clock-in and error out if it was in the same day, and also error if there was no clock-in that day. You'll be able to yield more useful error messages that way. Then you can insert...

INSERT INTO clock_in(user_id, created_at, local_date) (
  SELECT 1, now(),
  (date_trunc('day', now() AT TIME ZONE 'insert_users_timezone_here'))::date
);

Usage example for a client who has indicated it's in the PST timezone:

me=# CREATE TABLE clock_in ( user_id bigint NOT NULL, created_at timestamptz NOT NULL, local_date date NOT NULL, UNIQUE(user_id, local_date) );
CREATE TABLE
me=# INSERT INTO clock_in(user_id, created_at, local_date) ( SELECT 1, now(), (date_trunc('day', now() AT TIME ZONE 'PST'))::date );
INSERT 0 1
me=# INSERT INTO clock_in(user_id, created_at, local_date) ( SELECT 1, now(), (date_trunc('day', now() AT TIME ZONE 'PST'))::date );
ERROR: duplicate key value violates unique constraint "clock_in_user_id_local_date_key"
DETAIL: Key (user_id, local_date)=(1, 2022-04-13) already exists.
me=# INSERT INTO clock_in(user_id, created_at, local_date) ( SELECT 1, now(), (date_trunc('day', now() AT TIME ZONE 'PST' + interval '10' hour))::date );
INSERT 0 1
me=#

Then you'd do the same for clock-outs.

Using timestamptz instead of timestamp is deliberate. You should almost never use timestamp, for reasons other answers describe well.

user_18843630

Firstly, you'll probably want to use a native datetime datatype and a range one at that, e.g. tstzrange (with timezone) / tsrange (without timezone) – they allow you to natively store a start and end time – see https://www.postgresql.org/docs/current/rangetypes.html#RANGETYPES-BUILTIN

You can optionally add an exclusion constraint to ensure no two shifts overlap – see: https://www.postgresql.org/docs/current/rangetypes.html#RANGETYPES-CONSTRAINT if that's all you really want to ensure, then that might be enough.

If you definitely want to ensure there's only one shift starting or ending per day, you can use a function to derive a unique index:

create unique index INDEX_NAME on TABLE_NAME (date_trunc('day', lower(column_name)))

For your example specifically:

create unique index idx_unique_shift_start_time on entries (user_id, date_trunc('day', lower(active_during)))

create unique index idx_unique_shift_end_time on entries (user_id, date_trunc('day', upper(active_during)))

These two indexes take the lower or upper bounds of the range (i.e. the start time or end time), then truncate to just the day (i.e. drop the hours, minutes, seconds etc) and then combine with the user_id to give us a unique key.

user_1155400
Related