kinto 23.2.1__py3-none-any.whl

kinto/core/storage/postgresql/migrations/migration_014_015.sql

@@ -0,0 +1,95 @@
+--
+-- Helper that returns the current collection timestamp.
+--
+CREATE OR REPLACE FUNCTION collection_timestamp(uid VARCHAR, resource VARCHAR)
+RETURNS TIMESTAMP AS $$
+DECLARE
+    ts TIMESTAMP;
+BEGIN
+    WITH create_if_missing AS (
+      INSERT INTO timestamps (parent_id, collection_id, last_modified)
+      VALUES (uid, resource, clock_timestamp())
+      ON CONFLICT (parent_id, collection_id) DO NOTHING
+      RETURNING last_modified
+    ),
+    get_or_create AS (
+      SELECT last_modified FROM create_if_missing
+      UNION
+      SELECT last_modified FROM timestamps
+       WHERE parent_id = uid
+         AND collection_id = resource
+    )
+    SELECT last_modified INTO ts FROM get_or_create;
+
+    RETURN ts;
+END;
+$$ LANGUAGE plpgsql;
+
+--
+-- Triggers to set last_modified on INSERT/UPDATE
+--
+DROP TRIGGER IF EXISTS tgr_records_last_modified ON records;
+DROP TRIGGER IF EXISTS tgr_deleted_last_modified ON deleted;
+
+CREATE OR REPLACE FUNCTION bump_timestamp()
+RETURNS trigger AS $$
+DECLARE
+    previous TIMESTAMP;
+    current TIMESTAMP;
+
+BEGIN
+    previous := NULL;
+    SELECT last_modified INTO previous
+      FROM timestamps
+     WHERE parent_id = NEW.parent_id
+       AND collection_id = NEW.collection_id;
+
+    --
+    -- This bumps the current timestamp to 1 msec in the future if the previous
+    -- timestamp is equal to the current one (or higher if was bumped already).
+    --
+    -- If a bunch of requests from the same user on the same collection
+    -- arrive in the same millisecond, the unicity constraint can raise
+    -- an error (operation is cancelled).
+    -- See https://github.com/mozilla-services/cliquet/issues/25
+    --
+    current := clock_timestamp();
+    IF previous IS NOT NULL AND previous >= current THEN
+        current := previous + INTERVAL '1 milliseconds';
+    END IF;
+
+    IF NEW.last_modified IS NULL OR
+       (previous IS NOT NULL AND as_epoch(NEW.last_modified) = as_epoch(previous)) THEN
+        -- If record does not carry last-modified, or if the one specified
+        -- is equal to previous, assign it to current (i.e. bump it).
+        NEW.last_modified := current;
+    ELSE
+        -- Use record last-modified as collection timestamp.
+        IF previous IS NULL OR NEW.last_modified > previous THEN
+            current := NEW.last_modified;
+        END IF;
+    END IF;
+
+    --
+    -- Upsert current collection timestamp.
+    --
+    INSERT INTO timestamps (parent_id, collection_id, last_modified)
+    VALUES (NEW.parent_id, NEW.collection_id, current)
+    ON CONFLICT (parent_id, collection_id) DO UPDATE
+      SET last_modified = current;
+
+    RETURN NEW;
+END;
+$$ LANGUAGE plpgsql;
+
+CREATE TRIGGER tgr_records_last_modified
+BEFORE INSERT OR UPDATE OF data ON records
+FOR EACH ROW EXECUTE PROCEDURE bump_timestamp();
+
+CREATE TRIGGER tgr_deleted_last_modified
+BEFORE INSERT ON deleted
+FOR EACH ROW EXECUTE PROCEDURE bump_timestamp();
+
+
+-- Bump storage schema version.
+INSERT INTO metadata (name, value) VALUES ('storage_schema_version', '15');

kinto/core/storage/postgresql/migrations/migration_015_016.sql

@@ -0,0 +1,4 @@
+DROP FUNCTION collection_timestamp(uid VARCHAR, resource VARCHAR);
+
+-- Bump storage schema version.
+INSERT INTO metadata (name, value) VALUES ('storage_schema_version', '16');

kinto/core/storage/postgresql/migrations/migration_016_017.sql

@@ -0,0 +1,81 @@
+--
+-- Triggers to set last_modified on INSERT/UPDATE
+--
+DROP TRIGGER IF EXISTS tgr_records_last_modified ON records;
+DROP TRIGGER IF EXISTS tgr_deleted_last_modified ON deleted;
+
+CREATE OR REPLACE FUNCTION bump_timestamp()
+RETURNS trigger AS $$
+DECLARE
+    previous TIMESTAMP;
+    current TIMESTAMP;
+BEGIN
+    previous := NULL;
+    WITH existing_timestamps AS (
+      -- Timestamp of latest record.
+      (
+        SELECT last_modified
+        FROM records
+        WHERE parent_id = NEW.parent_id
+          AND collection_id = NEW.collection_id
+        ORDER BY last_modified DESC
+        LIMIT 1
+      )
+      -- Timestamp of latest tombstone.
+      UNION
+      (
+        SELECT last_modified
+        FROM deleted
+        WHERE parent_id = NEW.parent_id
+          AND collection_id = NEW.collection_id
+        ORDER BY last_modified DESC
+        LIMIT 1
+      )
+      -- Timestamp when collection was empty.
+      UNION
+      (
+        SELECT last_modified
+        FROM timestamps
+        WHERE parent_id = NEW.parent_id
+          AND collection_id = NEW.collection_id
+      )
+    )
+    SELECT MAX(last_modified) INTO previous
+      FROM existing_timestamps;
+
+    --
+    -- This bumps the current timestamp to 1 msec in the future if the previous
+    -- timestamp is equal to the current one (or higher if was bumped already).
+    --
+    -- If a bunch of requests from the same user on the same collection
+    -- arrive in the same millisecond, the unicity constraint can raise
+    -- an error (operation is cancelled).
+    -- See https://github.com/mozilla-services/cliquet/issues/25
+    --
+    current := clock_timestamp();
+    IF previous IS NOT NULL AND previous >= current THEN
+        current := previous + INTERVAL '1 milliseconds';
+    END IF;
+
+    IF NEW.last_modified IS NULL OR
+       (previous IS NOT NULL AND as_epoch(NEW.last_modified) = as_epoch(previous)) THEN
+        -- If record does not carry last-modified, or if the one specified
+        -- is equal to previous, assign it to current (i.e. bump it).
+        NEW.last_modified := current;
+    END IF;
+
+    RETURN NEW;
+END;
+$$ LANGUAGE plpgsql;
+
+CREATE TRIGGER tgr_records_last_modified
+BEFORE INSERT OR UPDATE OF data ON records
+FOR EACH ROW EXECUTE PROCEDURE bump_timestamp();
+
+CREATE TRIGGER tgr_deleted_last_modified
+BEFORE INSERT ON deleted
+FOR EACH ROW EXECUTE PROCEDURE bump_timestamp();
+
+
+-- Bump storage schema version.
+INSERT INTO metadata (name, value) VALUES ('storage_schema_version', '17');

kinto/core/storage/postgresql/migrations/migration_017_018.sql

@@ -0,0 +1,25 @@
+-- Add new deleted column (split into commands is more efficient)
+ALTER TABLE records ADD COLUMN deleted BOOLEAN;
+UPDATE records SET deleted = FALSE;
+ALTER TABLE records ALTER COLUMN deleted SET NOT NULL;
+ALTER TABLE records ALTER COLUMN deleted SET DEFAULT FALSE;
+
+
+-- Lock records and deleted tables before merging them.
+BEGIN WORK;
+LOCK TABLE records IN ACCESS EXCLUSIVE MODE;
+LOCK TABLE deleted IN ACCESS EXCLUSIVE MODE;
+
+INSERT INTO records (id, parent_id, collection_id, data, last_modified, deleted)
+  SELECT id, parent_id, collection_id, '{"deleted": true}'::JSONB, last_modified, TRUE
+  FROM deleted
+-- Because of Bug Kinto/kinto#1375, some tombstones may exist.
+  ON CONFLICT (id, parent_id, collection_id) DO NOTHING;
+COMMIT WORK;
+-- Table merged.
+
+-- We do not drop the `deleted` table here.
+-- It can be dropped manually once Web heads run the appropriate Kinto version.
+
+-- Bump storage schema version.
+INSERT INTO metadata (name, value) VALUES ('storage_schema_version', '18');

kinto/core/storage/postgresql/migrations/migration_018_019.sql

@@ -0,0 +1,8 @@
+-- Alter collation to C to improve LIKE-prefix queries in delete_all.
+ALTER TABLE records
+    ALTER COLUMN id TYPE TEXT COLLATE "C",
+    ALTER COLUMN parent_id TYPE TEXT COLLATE "C",
+    ALTER COLUMN collection_id TYPE TEXT COLLATE "C";
+
+-- Bump storage schema version.
+INSERT INTO metadata (name, value) VALUES ('storage_schema_version', '19');

kinto/core/storage/postgresql/migrations/migration_019_020.sql

@@ -0,0 +1,7 @@
+-- Alter collation to C to improve LIKE-prefix queries in delete_all.
+ALTER TABLE timestamps
+    ALTER COLUMN parent_id TYPE TEXT COLLATE "C",
+    ALTER COLUMN collection_id TYPE TEXT COLLATE "C";
+
+-- Bump storage schema version.
+INSERT INTO metadata (name, value) VALUES ('storage_schema_version', '20');

kinto/core/storage/postgresql/migrations/migration_020_021.sql

@@ -0,0 +1,68 @@
+ALTER TABLE records RENAME COLUMN collection_id TO resource_name;
+ALTER TABLE records RENAME TO objects;
+ALTER TABLE timestamps RENAME COLUMN collection_id TO resource_name;
+ALTER INDEX idx_records_parent_id_collection_id_last_modified RENAME TO idx_objects_parent_id_resource_name_last_modified;
+ALTER INDEX idx_records_last_modified_epoch RENAME TO idx_objects_last_modified_epoch;
+
+DROP TRIGGER IF EXISTS tgr_records_last_modified ON objects;
+
+CREATE OR REPLACE FUNCTION bump_timestamp()
+RETURNS trigger AS $$
+DECLARE
+    previous TIMESTAMP;
+    current TIMESTAMP;
+BEGIN
+    previous := NULL;
+    WITH existing_timestamps AS (
+      -- Timestamp of latest record.
+      (
+        SELECT last_modified
+        FROM objects
+        WHERE parent_id = NEW.parent_id
+          AND resource_name = NEW.resource_name
+        ORDER BY last_modified DESC
+        LIMIT 1
+      )
+      -- Timestamp when collection was empty.
+      UNION
+      (
+        SELECT last_modified
+        FROM timestamps
+        WHERE parent_id = NEW.parent_id
+          AND resource_name = NEW.resource_name
+      )
+    )
+    SELECT MAX(last_modified) INTO previous
+      FROM existing_timestamps;
+
+    --
+    -- This bumps the current timestamp to 1 msec in the future if the previous
+    -- timestamp is equal to the current one (or higher if was bumped already).
+    --
+    -- If a bunch of requests from the same user on the same collection
+    -- arrive in the same millisecond, the unicity constraint can raise
+    -- an error (operation is cancelled).
+    -- See https://github.com/mozilla-services/cliquet/issues/25
+    --
+    current := clock_timestamp();
+    IF previous IS NOT NULL AND previous >= current THEN
+        current := previous + INTERVAL '1 milliseconds';
+    END IF;
+
+    IF NEW.last_modified IS NULL OR
+       (previous IS NOT NULL AND as_epoch(NEW.last_modified) = as_epoch(previous)) THEN
+        -- If record does not carry last-modified, or if the one specified
+        -- is equal to previous, assign it to current (i.e. bump it).
+        NEW.last_modified := current;
+    END IF;
+
+    RETURN NEW;
+END;
+$$ LANGUAGE plpgsql;
+
+CREATE TRIGGER tgr_objects_last_modified
+BEFORE INSERT OR UPDATE OF data ON objects
+FOR EACH ROW EXECUTE PROCEDURE bump_timestamp();
+
+-- Bump storage schema version.
+INSERT INTO metadata (name, value) VALUES ('storage_schema_version', '21');

kinto/core/storage/postgresql/migrations/migration_021_022.sql

@@ -0,0 +1,62 @@
+DROP TRIGGER IF EXISTS tgr_objects_last_modified ON objects;
+
+CREATE OR REPLACE FUNCTION bump_timestamp()
+RETURNS trigger AS $$
+DECLARE
+    previous BIGINT;
+    current BIGINT;
+BEGIN
+    previous := NULL;
+    WITH existing_timestamps AS (
+      -- Timestamp of latest record.
+      (
+        SELECT last_modified
+        FROM objects
+        WHERE parent_id = NEW.parent_id
+          AND resource_name = NEW.resource_name
+        ORDER BY as_epoch(last_modified) DESC
+        LIMIT 1
+      )
+      -- Timestamp when resource was empty.
+      UNION
+      (
+        SELECT last_modified
+        FROM timestamps
+        WHERE parent_id = NEW.parent_id
+          AND resource_name = NEW.resource_name
+      )
+    )
+    SELECT as_epoch(MAX(last_modified)) INTO previous
+      FROM existing_timestamps;
+
+    --
+    -- This bumps the current timestamp to 1 msec in the future if the previous
+    -- timestamp is equal to the current one (or higher if was bumped already).
+    --
+    -- If a bunch of requests from the same user on the same resource
+    -- arrive in the same millisecond, the unicity constraint can raise
+    -- an error (operation is cancelled).
+    -- See https://github.com/mozilla-services/cliquet/issues/25
+    --
+    current := as_epoch(clock_timestamp()::TIMESTAMP);
+    IF previous IS NOT NULL AND previous >= current THEN
+        current := previous + 1;
+    END IF;
+
+    IF NEW.last_modified IS NULL OR
+       (previous IS NOT NULL AND as_epoch(NEW.last_modified) = previous) THEN
+        -- If record does not carry last-modified, or if the one specified
+        -- is equal to previous, assign it to current (i.e. bump it).
+        NEW.last_modified := from_epoch(current);
+    END IF;
+
+    RETURN NEW;
+END;
+$$ LANGUAGE plpgsql;
+
+CREATE TRIGGER tgr_objects_last_modified
+BEFORE INSERT OR UPDATE OF data ON objects
+FOR EACH ROW EXECUTE PROCEDURE bump_timestamp();
+
+-- Bump storage schema version.
+INSERT INTO metadata (name, value) VALUES ('storage_schema_version', '22');

kinto/core/storage/postgresql/migrations/migration_022_023.sql

@@ -0,0 +1,5 @@
+CREATE INDEX IF NOT EXISTS idx_objects_resource_name_parent_id_deleted
+    ON objects(resource_name, parent_id, deleted);
+
+-- Bump storage schema version.
+INSERT INTO metadata (name, value) VALUES ('storage_schema_version', '23');

kinto/core/storage/postgresql/migrations/migration_023_024.sql

@@ -0,0 +1,6 @@
+CREATE INDEX idx_objects_history_userid_and_resourcename
+  ON objects ((data->'user_id'), (data->'resource_name'))
+  WHERE resource_name = 'history';
+
+-- Bump storage schema version.
+INSERT INTO metadata (name, value) VALUES ('storage_schema_version', '24');

kinto/core/storage/postgresql/migrations/migration_024_025.sql

@@ -0,0 +1,6 @@
+CREATE INDEX IF NOT EXISTS idx_objects_parent_id_record_last_modified
+    ON objects (parent_id, last_modified DESC)
+    WHERE resource_name = 'record';
+
+-- Bump storage schema version.
+INSERT INTO metadata (name, value) VALUES ('storage_schema_version', '25');

kinto/core/storage/postgresql/migrator.py

@@ -0,0 +1,98 @@
+"""
+A helper class to run migrations using a series of SQL files.
+"""
+
+import logging
+import os
+
+from kinto.core.utils import sqlalchemy as sa
+
+
+logger = logging.getLogger(__name__)
+
+
+class MigratorMixin:
+    """Mixin to allow the running of migrations.
+
+    Your class must provide a `client` attribute (a PostgreSQLClient),
+    as well as override some class attributes.
+    """
+
+    """Name of this migrator (e.g. "storage"). Override this."""
+    name = None
+
+    """The current "newest" schema version. Override this."""
+    schema_version = None
+
+    """The file to find the current "newest" schema in. Override this."""
+    schema_file = None
+
+    """The directory to find migration files in.
+
+    Migrations should each be a file named migration_nnn_mmm.sql, where mmm = nnn + 1.
+    """
+    migrations_directory = None
+
+    def get_installed_version(self):
+        """Return current version of schema or None if none found.
+
+        Override this.
+
+        This may be called several times during a single migration.
+        """
+        raise NotImplementedError("method not overridden")  # pragma: no cover
+
+    def create_or_migrate_schema(self, dry_run=False):
+        """Either create or migrate the schema, as needed."""
+        version = self.get_installed_version()
+        if not version:
+            self.create_schema(dry_run)
+            return
+
+        logger.info(f"Detected PostgreSQL {self.name} schema version {version}.")
+        if version == self.schema_version:
+            logger.info(f"PostgreSQL {self.name} schema is up-to-date.")
+            return
+
+        self.migrate_schema(version, dry_run)
+
+    def create_schema(self, dry_run):
+        """Actually create the schema from scratch using self.schema_file.
+
+        You can override this if you want to add additional sanity checks.
+        """
+        logger.info(
+            f"Create PostgreSQL {self.name} schema at version {self.schema_version} from {self.schema_file}."
+        )
+        if not dry_run:
+            self._execute_sql_file(self.schema_file)
+            logger.info(f"Created PostgreSQL {self.name} schema (version {self.schema_version}).")
+
+    def migrate_schema(self, start_version, dry_run):
+        migrations = [(v, v + 1) for v in range(start_version, self.schema_version)]
+        for migration in migrations:
+            expected = migration[0]
+            current = self.get_installed_version()
+            error_msg = f"PostgreSQL {self.name} schema: Expected version {expected}. Found version {current}."
+            if not dry_run and expected != current:
+                raise AssertionError(error_msg)
+
+            logger.info(
+                f"Migrate PostgreSQL {self.name} schema from version {migration[0]} to {migration[1]}."
+            )
+            filename = "migration_{0:03d}_{1:03d}.sql".format(*migration)
+            filepath = os.path.join(self.migrations_directory, filename)
+            logger.info(f"Execute PostgreSQL {self.name} migration from {filepath}")
+            if not dry_run:
+                self._execute_sql_file(filepath)
+        logger.info(
+            f"PostgreSQL {self.name} schema migration {'simulated' if dry_run else 'done'}"
+        )
+
+    def _execute_sql_file(self, filepath):
+        """Helper method to execute the SQL in a file."""
+        with open(filepath) as f:
+            schema = f.read()
+        # Since called outside request, force commit.
+        with self.client.connect(force_commit=True) as conn:
+            conn.execute(sa.text(schema))

kinto/core/storage/postgresql/pool.py

@@ -0,0 +1,55 @@
+from sqlalchemy.pool import QueuePool
+from sqlalchemy.util.queue import Queue
+
+
+class _QueueWithMaxBacklog(Queue):
+    """SQLAlchemy Queue subclass with a limit on the length of the backlog.
+
+    This base Queue class sets no limit on the number of threads that can be
+    simultaneously blocked waiting for an item on the queue.  This class
+    adds a "max_backlog" parameter that can be used to bound this number.
+    """
+
+    def __init__(self, maxsize=0, max_backlog=-1):
+        self.max_backlog = max_backlog
+        self.cur_backlog = 0
+        Queue.__init__(self, maxsize)
+
+    def get(self, block=True, timeout=None):
+        # The SQLAlchemy Queue class uses a re-entrant mutext by default,
+        # so it's safe to acquire it both here and in the superclass method.
+        with self.mutex:
+            self.cur_backlog += 1
+            try:
+                if self.max_backlog >= 0:  # pragma: no branch
+                    if self.cur_backlog > self.max_backlog:
+                        block = False
+                        timeout = None
+                return Queue.get(self, block, timeout)
+            finally:
+                self.cur_backlog -= 1
+
+
+class QueuePoolWithMaxBacklog(QueuePool):
+    """An SQLAlchemy QueuePool with a limit on the length of the backlog.
+
+    The base QueuePool class sets no limit on the number of threads that can
+    be simultaneously attempting to connect to the database.  This means that
+    a misbehaving database can easily lock up all threads by keeping them
+    waiting in the queue.
+
+    This QueuePool subclass provides a "max_backlog" that limits the number
+    of threads that can be in the queue waiting for a connection.  Once this
+    limit has been reached, any further attempts to acquire a connection will
+    be rejected immediately.
+    """
+
+    def __init__(self, creator, max_backlog=-1, **kwds):
+        kwds.setdefault("pool_size", 25)
+        QueuePool.__init__(self, creator, **kwds)
+        self._pool = _QueueWithMaxBacklog(self._pool.maxsize, max_backlog)
+
+    def recreate(self):
+        new_self = QueuePool.recreate(self)
+        new_self._pool = _QueueWithMaxBacklog(self._pool.maxsize, self._pool.max_backlog)
+        return new_self

kinto/core/storage/postgresql/schema.sql

@@ -0,0 +1,143 @@
+--
+-- Automated script, we do not need NOTICE and WARNING
+--
+SET client_min_messages TO ERROR;
+--
+-- Convert timestamps to milliseconds epoch integer
+--
+CREATE OR REPLACE FUNCTION as_epoch(ts TIMESTAMP) RETURNS BIGINT AS $$
+BEGIN
+    RETURN (EXTRACT(EPOCH FROM ts) * 1000)::BIGINT;
+END;
+$$ LANGUAGE plpgsql
+IMMUTABLE;
+
+CREATE OR REPLACE FUNCTION from_epoch(epoch BIGINT) RETURNS TIMESTAMP AS $$
+BEGIN
+    RETURN TIMESTAMP WITH TIME ZONE 'epoch' + epoch * INTERVAL '1 millisecond';
+END;
+$$ LANGUAGE plpgsql
+IMMUTABLE;
+
+--
+-- Actual objects
+--
+CREATE TABLE IF NOT EXISTS objects (
+    -- These are all IDs stored as text, and not human language.
+    -- Therefore, we store them in the C collation. This lets Postgres
+    -- use the index on parent_id for prefix matching (parent_id LIKE
+    -- '/buckets/abc/%').
+    id TEXT COLLATE "C" NOT NULL,
+    parent_id TEXT COLLATE "C" NOT NULL,
+    resource_name TEXT COLLATE "C" NOT NULL,
+
+    -- Timestamp is relevant because adequate semantically.
+    -- Since the HTTP API manipulates integers, it could make sense
+    -- to replace the timestamp columns type by integer.
+    last_modified TIMESTAMP NOT NULL,
+
+    -- JSONB, 2x faster than JSON.
+    data JSONB NOT NULL DEFAULT '{}'::JSONB,
+
+    deleted BOOLEAN NOT NULL,
+
+    PRIMARY KEY (id, parent_id, resource_name)
+);
+CREATE UNIQUE INDEX IF NOT EXISTS idx_objects_parent_id_resource_name_last_modified
+    ON objects(parent_id, resource_name, last_modified DESC);
+CREATE INDEX IF NOT EXISTS idx_objects_last_modified_epoch
+    ON objects(as_epoch(last_modified));
+CREATE INDEX IF NOT EXISTS idx_objects_resource_name_parent_id_deleted
+    ON objects(resource_name, parent_id, deleted);
+-- Index for collections timestamps
+CREATE INDEX IF NOT EXISTS idx_objects_parent_id_record_last_modified
+    ON objects (parent_id, last_modified DESC)
+    WHERE resource_name = 'record';
+-- Index for history plugin trimming.
+CREATE INDEX IF NOT EXISTS idx_objects_history_userid_and_resourcename
+    ON objects ((data->'user_id'), (data->'resource_name'))
+    WHERE resource_name = 'history';
+
+CREATE TABLE IF NOT EXISTS timestamps (
+  parent_id TEXT NOT NULL COLLATE "C",
+  resource_name TEXT NOT NULL COLLATE "C",
+  last_modified TIMESTAMP NOT NULL,
+  PRIMARY KEY (parent_id, resource_name)
+);
+
+--
+-- Triggers to set last_modified on INSERT/UPDATE
+--
+DROP TRIGGER IF EXISTS tgr_objects_last_modified ON objects;
+
+CREATE OR REPLACE FUNCTION bump_timestamp()
+RETURNS trigger AS $$
+DECLARE
+    previous BIGINT;
+    current BIGINT;
+BEGIN
+    previous := NULL;
+    WITH existing_timestamps AS (
+      -- Timestamp of latest record.
+      (
+        SELECT last_modified
+        FROM objects
+        WHERE parent_id = NEW.parent_id
+          AND resource_name = NEW.resource_name
+        ORDER BY as_epoch(last_modified) DESC
+        LIMIT 1
+      )
+      -- Timestamp when resource was empty.
+      UNION
+      (
+        SELECT last_modified
+        FROM timestamps
+        WHERE parent_id = NEW.parent_id
+          AND resource_name = NEW.resource_name
+      )
+    )
+    SELECT as_epoch(MAX(last_modified)) INTO previous
+      FROM existing_timestamps;
+
+    --
+    -- This bumps the current timestamp to 1 msec in the future if the previous
+    -- timestamp is equal to the current one (or higher if was bumped already).
+    --
+    -- If a bunch of requests from the same user on the same resource
+    -- arrive in the same millisecond, the unicity constraint can raise
+    -- an error (operation is cancelled).
+    -- See https://github.com/mozilla-services/cliquet/issues/25
+    --
+    current := as_epoch(clock_timestamp()::TIMESTAMP);
+    IF previous IS NOT NULL AND previous >= current THEN
+        current := previous + 1;
+    END IF;
+
+    IF NEW.last_modified IS NULL OR
+       (previous IS NOT NULL AND as_epoch(NEW.last_modified) = previous) THEN
+        -- If record does not carry last-modified, or if the one specified
+        -- is equal to previous, assign it to current (i.e. bump it).
+        NEW.last_modified := from_epoch(current);
+    END IF;
+
+    RETURN NEW;
+END;
+$$ LANGUAGE plpgsql;
+
+CREATE TRIGGER tgr_objects_last_modified
+BEFORE INSERT OR UPDATE OF data ON objects
+FOR EACH ROW EXECUTE PROCEDURE bump_timestamp();
+
+--
+-- Metadata table
+--
+CREATE TABLE IF NOT EXISTS metadata (
+    name VARCHAR(128) NOT NULL,
+    value VARCHAR(512) NOT NULL
+);
+INSERT INTO metadata (name, value) VALUES ('created_at', NOW()::TEXT);
+
+
+-- Set storage schema version.
+-- Should match ``kinto.core.storage.postgresql.PostgreSQL.schema_version``
+INSERT INTO metadata (name, value) VALUES ('storage_schema_version', '25');