--
-- PostgreSQL database dump
--
 
SET client_encoding = 'UTF8';
SET check_function_bodies = false;
SET client_min_messages = warning;
 
--
-- Name: SCHEMA public; Type: COMMENT; Schema: -; Owner: postgres
--
 
COMMENT ON SCHEMA public IS 'Standard public schema';
 
 
--
-- Name: plpgsql; Type: PROCEDURAL LANGUAGE; Schema: -; Owner: 
--
 
CREATE PROCEDURAL LANGUAGE plpgsql;
 
 
SET search_path = public, pg_catalog;
 
--
-- Name: concat_ignore_null(character varying, character varying); Type: FUNCTION; Schema: public; Owner: po_user
--
 
CREATE FUNCTION concat_ignore_null(character varying, character varying) RETURNS character varying
    AS $_$ declare string_1         alias FOR $1; string_2         alias FOR $2; begin IF string_1 IS NULL then RETURN string_2; end IF;  IF string_2 IS NULL then RETURN string_1; end IF;  RETURN string_1||string_2; end; $_$
    LANGUAGE plpgsql;
 
 
ALTER FUNCTION public.concat_ignore_null(character varying, character varying) OWNER TO po_user;
 
--
-- Name: count_albums_by_user(integer); Type: FUNCTION; Schema: public; Owner: po_user
--
 
CREATE FUNCTION count_albums_by_user(integer) RETURNS bigint
    AS $_$select count(identifier) FROM album WHERE users = $1$_$
    LANGUAGE sql;
 
 
ALTER FUNCTION public.count_albums_by_user(integer) OWNER TO po_user;
 
--
-- Name: count_albums_by_user(integer, integer); Type: FUNCTION; Schema: public; Owner: po_user
--
 
CREATE FUNCTION count_albums_by_user(integer, integer) RETURNS bigint
    AS $_$select count(identifier) FROM album WHERE users = $1 AND access_rights <= $2$_$
    LANGUAGE sql;
 
 
ALTER FUNCTION public.count_albums_by_user(integer, integer) OWNER TO po_user;
 
--
-- Name: count_equipment_by_user(integer); Type: FUNCTION; Schema: public; Owner: po_user
--
 
CREATE FUNCTION count_equipment_by_user(integer) RETURNS bigint
    AS $_$select ((SELECT count(identifier) FROM lens WHERE users = $1) + (SELECT count(identifier) FROM camera WHERE users = $1) + (SELECT count(identifier) FROM flash WHERE users = $1) + (SELECT count(identifier) FROM scanner WHERE users = $1) + (SELECT count(identifier) FROM film WHERE users = $1) + (SELECT count(identifier) FROM support WHERE users = $1) + (SELECT count(identifier) FROM flash WHERE users = $1))$_$
    LANGUAGE sql;
 
 
ALTER FUNCTION public.count_equipment_by_user(integer) OWNER TO po_user;
 
--
-- Name: count_equipment_by_user(integer, integer); Type: FUNCTION; Schema: public; Owner: po_user
--
 
CREATE FUNCTION count_equipment_by_user(integer, integer) RETURNS bigint
    AS $_$select ((SELECT count(identifier) FROM lens WHERE users = $1 AND access_rights <= $2) + (SELECT count(identifier) FROM camera WHERE users = $1 AND access_rights <= $2) + (SELECT count(identifier) FROM flash WHERE users = $1 AND access_rights <= $2) + (SELECT count(identifier) FROM scanner WHERE users = $1 AND access_rights <= $2) + (SELECT count(identifier) FROM film WHERE users = $1 AND access_rights <= $2) + (SELECT count(identifier) FROM support WHERE users = $1 AND access_rights <= $2) + (SELECT count(identifier) FROM flash WHERE users = $1 AND access_rights <= $2))$_$
    LANGUAGE sql;
 
 
ALTER FUNCTION public.count_equipment_by_user(integer, integer) OWNER TO po_user;
 
--
-- Name: count_folders_by_user(integer); Type: FUNCTION; Schema: public; Owner: po_user
--
 
CREATE FUNCTION count_folders_by_user(integer) RETURNS bigint
    AS $_$select count(identifier) FROM folder WHERE users = $1$_$
    LANGUAGE sql;
 
 
ALTER FUNCTION public.count_folders_by_user(integer) OWNER TO po_user;
 
--
-- Name: count_folders_by_user(integer, integer); Type: FUNCTION; Schema: public; Owner: po_user
--
 
CREATE FUNCTION count_folders_by_user(integer, integer) RETURNS bigint
    AS $_$select count(identifier) FROM folder WHERE users = $1 AND access_rights <= $2$_$
    LANGUAGE sql;
 
 
ALTER FUNCTION public.count_folders_by_user(integer, integer) OWNER TO po_user;
 
--
-- Name: count_photo_versions(); Type: FUNCTION; Schema: public; Owner: po_user
--
 
CREATE FUNCTION count_photo_versions() RETURNS bigint
    AS $$select count(identifier) FROM photo_version$$
    LANGUAGE sql;
 
 
ALTER FUNCTION public.count_photo_versions() OWNER TO po_user;
 
--
-- Name: count_photo_versions_by_user(integer); Type: FUNCTION; Schema: public; Owner: po_user
--
 
CREATE FUNCTION count_photo_versions_by_user(integer) RETURNS bigint
    AS $_$select count(photo_version.identifier) FROM photo_version, photo WHERE photo_version.photo=photo.identifier AND photo.users = $1$_$
    LANGUAGE sql;
 
 
ALTER FUNCTION public.count_photo_versions_by_user(integer) OWNER TO po_user;
 
--
-- Name: count_photos(); Type: FUNCTION; Schema: public; Owner: po_user
--
 
CREATE FUNCTION count_photos() RETURNS bigint
    AS $$select count(identifier) FROM photo$$
    LANGUAGE sql;
 
 
ALTER FUNCTION public.count_photos() OWNER TO po_user;
 
--
-- Name: count_photos(integer); Type: FUNCTION; Schema: public; Owner: po_user
--
 
CREATE FUNCTION count_photos(integer) RETURNS bigint
    AS $_$select count(identifier) FROM photo WHERE access_rights <= $1$_$
    LANGUAGE sql;
 
 
ALTER FUNCTION public.count_photos(integer) OWNER TO po_user;
 
--
-- Name: count_photos_by_album(integer); Type: FUNCTION; Schema: public; Owner: po_user
--
 
CREATE FUNCTION count_photos_by_album(integer) RETURNS bigint
    AS $_$select count(photo.identifier) FROM album_content, photo WHERE album_content.photo=photo.identifier AND album = $1$_$
    LANGUAGE sql;
 
 
ALTER FUNCTION public.count_photos_by_album(integer) OWNER TO po_user;
 
--
-- Name: count_photos_by_album(integer, integer); Type: FUNCTION; Schema: public; Owner: po_user
--
 
CREATE FUNCTION count_photos_by_album(integer, integer) RETURNS bigint
    AS $_$select count(photo.identifier) FROM album_content, photo, album WHERE album_content.photo=photo.identifier AND album_content.album=album.identifier AND album_content.album = $1 AND photo.access_rights <= $2$_$
    LANGUAGE sql;
 
 
ALTER FUNCTION public.count_photos_by_album(integer, integer) OWNER TO po_user;
 
--
-- Name: count_photos_by_folder(integer); Type: FUNCTION; Schema: public; Owner: po_user
--
 
CREATE FUNCTION count_photos_by_folder(integer) RETURNS bigint
    AS $_$select count(identifier) FROM photo WHERE folder = $1$_$
    LANGUAGE sql;
 
 
ALTER FUNCTION public.count_photos_by_folder(integer) OWNER TO po_user;
 
--
-- Name: count_photos_by_folder(integer, integer); Type: FUNCTION; Schema: public; Owner: po_user
--
 
CREATE FUNCTION count_photos_by_folder(integer, integer) RETURNS bigint
    AS $_$select count(identifier) FROM photo WHERE folder = $1 AND access_rights <= $2$_$
    LANGUAGE sql;
 
 
ALTER FUNCTION public.count_photos_by_folder(integer, integer) OWNER TO po_user;
 
--
-- Name: count_photos_by_user(integer); Type: FUNCTION; Schema: public; Owner: po_user
--
 
CREATE FUNCTION count_photos_by_user(integer) RETURNS bigint
    AS $_$select count(identifier) FROM photo WHERE users = $1$_$
    LANGUAGE sql;
 
 
ALTER FUNCTION public.count_photos_by_user(integer) OWNER TO po_user;
 
--
-- Name: count_photos_by_user(integer, integer); Type: FUNCTION; Schema: public; Owner: po_user
--
 
CREATE FUNCTION count_photos_by_user(integer, integer) RETURNS bigint
    AS $_$select count(photo.identifier) FROM photo, folder WHERE photo.folder=folder.identifier AND photo.users = $1 AND photo.access_rights <= $2 AND (folder.access_rights <= $2 OR (SELECT album.access_rights FROM album, album_content WHERE album_content.album=album.identifier AND album_content.photo=photo.identifier AND album.access_rights <= $2 LIMIT 1) <= $2) $_$
    LANGUAGE sql;
 
 
ALTER FUNCTION public.count_photos_by_user(integer, integer) OWNER TO po_user;
 
--
-- Name: count_subalbums_by_album(integer); Type: FUNCTION; Schema: public; Owner: po_user
--
 
CREATE FUNCTION count_subalbums_by_album(integer) RETURNS bigint
    AS $_$select count(identifier) FROM album WHERE parent_album = $1$_$
    LANGUAGE sql;
 
 
ALTER FUNCTION public.count_subalbums_by_album(integer) OWNER TO po_user;
 
--
-- Name: count_subalbums_by_album(integer, integer); Type: FUNCTION; Schema: public; Owner: po_user
--
 
CREATE FUNCTION count_subalbums_by_album(integer, integer) RETURNS bigint
    AS $_$select count(identifier) FROM album WHERE parent_album = $1 AND access_rights <= $2$_$
    LANGUAGE sql;
 
 
ALTER FUNCTION public.count_subalbums_by_album(integer, integer) OWNER TO po_user;
 
--
-- Name: count_subfolders_by_folder(integer); Type: FUNCTION; Schema: public; Owner: po_user
--
 
CREATE FUNCTION count_subfolders_by_folder(integer) RETURNS bigint
    AS $_$select count(identifier) FROM folder WHERE parent_folder = $1$_$
    LANGUAGE sql;
 
 
ALTER FUNCTION public.count_subfolders_by_folder(integer) OWNER TO po_user;
 
--
-- Name: count_subfolders_by_folder(integer, integer); Type: FUNCTION; Schema: public; Owner: po_user
--
 
CREATE FUNCTION count_subfolders_by_folder(integer, integer) RETURNS bigint
    AS $_$select count(identifier) FROM folder WHERE parent_folder = $1 AND access_rights <= $2$_$
    LANGUAGE sql;
 
 
ALTER FUNCTION public.count_subfolders_by_folder(integer, integer) OWNER TO po_user;
 
--
-- Name: count_users(); Type: FUNCTION; Schema: public; Owner: po_user
--
 
CREATE FUNCTION count_users() RETURNS bigint
    AS $$select count(identifier) FROM users$$
    LANGUAGE sql;
 
 
ALTER FUNCTION public.count_users() OWNER TO po_user;
 
--
-- Name: is_photo_for_sale(integer); Type: FUNCTION; Schema: public; Owner: po_user
--
 
CREATE FUNCTION is_photo_for_sale(integer) RETURNS bigint
    AS $_$select count(photo_item.identifier) FROM photo, photo_item WHERE photo.identifier=photo_item.photo AND photo.identifier = $1$_$
    LANGUAGE sql;
 
 
ALTER FUNCTION public.is_photo_for_sale(integer) OWNER TO po_user;
 
--
-- Name: is_user_my_client(integer, integer); Type: FUNCTION; Schema: public; Owner: po_user
--
 
CREATE FUNCTION is_user_my_client(integer, integer) RETURNS bigint
    AS $_$select count(identifier) FROM client WHERE client.users = $1 AND client.client = $2 AND STATUS=2$_$
    LANGUAGE sql;
 
 
ALTER FUNCTION public.is_user_my_client(integer, integer) OWNER TO po_user;
 
--
-- Name: number_of_camera_references(integer); Type: FUNCTION; Schema: public; Owner: po_user
--
 
CREATE FUNCTION number_of_camera_references(integer) RETURNS bigint
    AS $_$select count(photo_tech.identifier) FROM photo_tech, camera WHERE photo_tech.camera=camera.identifier AND camera.identifier = $1$_$
    LANGUAGE sql;
 
 
ALTER FUNCTION public.number_of_camera_references(integer) OWNER TO po_user;
 
--
-- Name: number_of_dupes(integer); Type: FUNCTION; Schema: public; Owner: po_user
--
 
CREATE FUNCTION number_of_dupes(integer) RETURNS bigint
    AS $_$select count(identifier) FROM photo_dupe WHERE photo = $1$_$
    LANGUAGE sql;
 
 
ALTER FUNCTION public.number_of_dupes(integer) OWNER TO po_user;
 
--
-- Name: number_of_film_references(integer); Type: FUNCTION; Schema: public; Owner: po_user
--
 
CREATE FUNCTION number_of_film_references(integer) RETURNS bigint
    AS $_$select count(photo_tech.identifier) FROM photo_tech, film WHERE photo_tech.film=film.identifier AND film.identifier = $1$_$
    LANGUAGE sql;
 
 
ALTER FUNCTION public.number_of_film_references(integer) OWNER TO po_user;
 
--
-- Name: number_of_filter_references(integer); Type: FUNCTION; Schema: public; Owner: po_user
--
 
CREATE FUNCTION number_of_filter_references(integer) RETURNS bigint
    AS $_$select count(photo_tech.identifier) FROM photo_tech, filter WHERE photo_tech.filter=filter.identifier AND filter.identifier = $1$_$
    LANGUAGE sql;
 
 
ALTER FUNCTION public.number_of_filter_references(integer) OWNER TO po_user;
 
--
-- Name: number_of_flash_references(integer); Type: FUNCTION; Schema: public; Owner: po_user
--
 
CREATE FUNCTION number_of_flash_references(integer) RETURNS bigint
    AS $_$select count(photo_tech.identifier) FROM photo_tech, flash WHERE photo_tech.flash=flash.identifier AND flash.identifier = $1$_$
    LANGUAGE sql;
 
 
ALTER FUNCTION public.number_of_flash_references(integer) OWNER TO po_user;
 
--
-- Name: number_of_lens_references(integer); Type: FUNCTION; Schema: public; Owner: po_user
--
 
CREATE FUNCTION number_of_lens_references(integer) RETURNS bigint
    AS $_$select count(photo_tech.identifier) FROM photo_tech, lens WHERE photo_tech.lens=lens.identifier AND lens.identifier = $1$_$
    LANGUAGE sql;
 
 
ALTER FUNCTION public.number_of_lens_references(integer) OWNER TO po_user;
 
--
-- Name: number_of_location_references(integer); Type: FUNCTION; Schema: public; Owner: po_user
--
 
CREATE FUNCTION number_of_location_references(integer) RETURNS bigint
    AS $_$select count(photo.identifier) FROM photo, location WHERE photo.location=location.identifier AND location.identifier = $1$_$
    LANGUAGE sql;
 
 
ALTER FUNCTION public.number_of_location_references(integer) OWNER TO po_user;
 
--
-- Name: number_of_manufacturer_ref(integer); Type: FUNCTION; Schema: public; Owner: po_user
--
 
CREATE FUNCTION number_of_manufacturer_ref(integer) RETURNS bigint
    AS $_$select ((SELECT count(identifier) FROM lens_type WHERE manufacturer = $1) + (SELECT count(identifier) FROM camera_type WHERE manufacturer = $1) + (SELECT count(identifier) FROM flash_type WHERE manufacturer = $1) + (SELECT count(identifier) FROM scanner_type WHERE manufacturer = $1) + (SELECT count(identifier) FROM support_type WHERE manufacturer = $1) + (SELECT count(identifier) FROM film_type WHERE manufacturer = $1) + (SELECT count(identifier) FROM flash_type WHERE manufacturer = $1))$_$
    LANGUAGE sql;
 
 
ALTER FUNCTION public.number_of_manufacturer_ref(integer) OWNER TO po_user;
 
--
-- Name: number_of_scanner_references(integer); Type: FUNCTION; Schema: public; Owner: po_user
--
 
CREATE FUNCTION number_of_scanner_references(integer) RETURNS bigint
    AS $_$select count(photo_tech.identifier) FROM photo_tech, scanner WHERE photo_tech.scanner=scanner.identifier AND scanner.identifier = $1$_$
    LANGUAGE sql;
 
 
ALTER FUNCTION public.number_of_scanner_references(integer) OWNER TO po_user;
 
--
-- Name: number_of_support_references(integer); Type: FUNCTION; Schema: public; Owner: po_user
--
 
CREATE FUNCTION number_of_support_references(integer) RETURNS bigint
    AS $_$select count(photo_tech.identifier) FROM photo_tech, support WHERE photo_tech.support=support.identifier AND support.identifier = $1$_$
    LANGUAGE sql;
 
 
ALTER FUNCTION public.number_of_support_references(integer) OWNER TO po_user;
 
--
-- Name: photo_shop_transaction_references(integer); Type: FUNCTION; Schema: public; Owner: po_user
--
 
CREATE FUNCTION photo_shop_transaction_references(integer) RETURNS bigint
    AS $_$select count(shop_order.transaction) FROM photo_item, shop_order WHERE photo_item.photo = $1 AND photo_item.identifier=shop_order.item$_$
    LANGUAGE sql;
 
 
ALTER FUNCTION public.photo_shop_transaction_references(integer) OWNER TO po_user;
 
--
-- Name: tokenized_ilike(character varying, character varying); Type: FUNCTION; Schema: public; Owner: po_user
--
 
CREATE FUNCTION tokenized_ilike(character varying, character varying) RETURNS BOOLEAN
    AS $_$ declare string alias FOR $1; keyword alias FOR $2; begin RETURN tokenized_like(lower(string), lower(keyword)); end; $_$
    LANGUAGE plpgsql;
 
 
ALTER FUNCTION public.tokenized_ilike(character varying, character varying) OWNER TO po_user;
 
--
-- Name: tokenized_ilike(integer, character varying); Type: FUNCTION; Schema: public; Owner: po_user
--
 
CREATE FUNCTION tokenized_ilike(integer, character varying) RETURNS BOOLEAN
    AS $_$ declare identifier alias FOR $1; keyword alias FOR $2; begin RETURN tokenized_ilike(text(identifier), keyword); end; $_$
    LANGUAGE plpgsql;
 
 
ALTER FUNCTION public.tokenized_ilike(integer, character varying) OWNER TO po_user;
 
--
-- Name: tokenized_like(character varying, character varying); Type: FUNCTION; Schema: public; Owner: po_user
--
 
CREATE FUNCTION tokenized_like(character varying, character varying) RETURNS BOOLEAN
    AS $_$ declare string alias FOR $1; keyword alias FOR $2;  token varchar; character char; string_length integer; token_length integer; token_begin integer; index_cursor integer; head_cursor integer; begin head_cursor := 1; string_length := char_length(string);  while head_cursor < string_length loop token_length := 0; index_cursor := head_cursor; token_begin := head_cursor; character := substring(string FROM index_cursor FOR 1); while index_cursor <= string_length loop IF ((character = ' ') OR (character = ';') OR (index_cursor = string_length)) then IF (index_cursor = string_length) then token_length := token_length + 1; end IF; token := substring(string FROM token_begin FOR token_length); IF (token = keyword) then RETURN true; end IF; end IF; token_length := token_length + 1; index_cursor := index_cursor + 1; character := substring(string FROM index_cursor FOR 1); end loop;  index_cursor := head_cursor; while index_cursor <= string_length loop character := substring(string FROM index_cursor FOR 1); IF ((character = ' ') OR (character = ';') OR (index_cursor = string_length)) then head_cursor := index_cursor + 1; exit; end IF; index_cursor := index_cursor + 1; end loop; end loop;  RETURN false; end; $_$
    LANGUAGE plpgsql;
 
 
ALTER FUNCTION public.tokenized_like(character varying, character varying) OWNER TO po_user;
 
--
-- Name: tokenized_like(integer, character varying); Type: FUNCTION; Schema: public; Owner: po_user
--
 
CREATE FUNCTION tokenized_like(integer, character varying) RETURNS BOOLEAN
    AS $_$ declare identifier alias FOR $1; keyword alias FOR $2; begin RETURN tokenized_like(text(identifier), keyword); end; $_$
    LANGUAGE plpgsql;
 
 
ALTER FUNCTION public.tokenized_like(integer, character varying) OWNER TO po_user;
 
--
-- Name: =##=; Type: OPERATOR; Schema: public; Owner: po_user
--
 
CREATE OPERATOR =##= (
    PROCEDURE = tokenized_ilike,
    LEFTARG = character varying,
    RIGHTARG = character varying,
    COMMUTATOR = =##=
);
 
 
ALTER OPERATOR public.=##= (character varying, character varying) OWNER TO po_user;
 
--
-- Name: =##=; Type: OPERATOR; Schema: public; Owner: po_user
--
 
CREATE OPERATOR =##= (
    PROCEDURE = tokenized_ilike,
    LEFTARG = integer,
    RIGHTARG = character varying,
    COMMUTATOR = =##=
);
 
 
ALTER OPERATOR public.=##= (integer, character varying) OWNER TO po_user;
 
--
-- Name: ====; Type: OPERATOR; Schema: public; Owner: po_user
--
 
CREATE OPERATOR ==== (
    PROCEDURE = tokenized_like,
    LEFTARG = character varying,
    RIGHTARG = character varying,
    COMMUTATOR = ====
);
 
 
ALTER OPERATOR public.==== (character varying, character varying) OWNER TO po_user;
 
--
-- Name: ====; Type: OPERATOR; Schema: public; Owner: po_user
--
 
CREATE OPERATOR ==== (
    PROCEDURE = tokenized_like,
    LEFTARG = integer,
    RIGHTARG = character varying,
    COMMUTATOR = ====
);
 
 
ALTER OPERATOR public.==== (integer, character varying) OWNER TO po_user;
 
--
-- Name: |||; Type: OPERATOR; Schema: public; Owner: po_user
--
 
CREATE OPERATOR ||| (
    PROCEDURE = concat_ignore_null,
    LEFTARG = character varying,
    RIGHTARG = character varying
);
 
 
ALTER OPERATOR public.||| (character varying, character varying) OWNER TO po_user;
 
SET default_tablespace = '';
 
SET default_with_oids = false;
 
--
-- Name: access_type; Type: TABLE; Schema: public; Owner: po_user; Tablespace: 
--
 
CREATE TABLE access_type (
    identifier integer NOT NULL,
    value character varying(10)
);
 
 
ALTER TABLE public.access_type OWNER TO po_user;
 
--
-- Name: access_type_id_sequence; Type: SEQUENCE; Schema: public; Owner: po_user
--
 
CREATE SEQUENCE access_type_id_sequence
    INCREMENT BY 1
    NO MAXVALUE
    NO MINVALUE
    CACHE 1;
 
 
ALTER TABLE public.access_type_id_sequence OWNER TO po_user;
 
--
-- Name: album; Type: TABLE; Schema: public; Owner: po_user; Tablespace: 
--
 
CREATE TABLE album (
    identifier integer NOT NULL,
    users integer NOT NULL,
    caption text,
    date_of_creation timestamp without time zone,
    access_rights integer NOT NULL,
    "type" character(1),
    orderby integer,
    description text,
    parent_album integer,
    CONSTRAINT album_type_check CHECK ((("type" = 'c'::bpchar) OR ("type" = 'u'::bpchar)))
);
 
 
ALTER TABLE public.album OWNER TO po_user;
 
--
-- Name: album_content; Type: TABLE; Schema: public; Owner: po_user; Tablespace: 
--
 
CREATE TABLE album_content (
    identifier integer NOT NULL,
    photo integer NOT NULL,
    album integer NOT NULL
);
 
 
ALTER TABLE public.album_content OWNER TO po_user;
 
--
-- Name: album_content_id_sequence; Type: SEQUENCE; Schema: public; Owner: po_user
--
 
CREATE SEQUENCE album_content_id_sequence
    START WITH 1
    INCREMENT BY 1
    NO MAXVALUE
    NO MINVALUE
    CACHE 1;
 
 
ALTER TABLE public.album_content_id_sequence OWNER TO po_user;
 
--
-- Name: album_id_sequence; Type: SEQUENCE; Schema: public; Owner: po_user
--
 
CREATE SEQUENCE album_id_sequence
    START WITH 1
    INCREMENT BY 1
    NO MAXVALUE
    NO MINVALUE
    CACHE 1;
 
 
ALTER TABLE public.album_id_sequence OWNER TO po_user;
 
--
-- Name: aperture; Type: TABLE; Schema: public; Owner: po_user; Tablespace: 
--
 
CREATE TABLE aperture (
    identifier integer NOT NULL,
    value numeric
);
 
 
ALTER TABLE public.aperture OWNER TO po_user;
 
--
-- Name: aperture_id_sequence; Type: SEQUENCE; Schema: public; Owner: po_user
--
 
CREATE SEQUENCE aperture_id_sequence
    INCREMENT BY 1
    NO MAXVALUE
    NO MINVALUE
    CACHE 1;
 
 
ALTER TABLE public.aperture_id_sequence OWNER TO po_user;
 
--
-- Name: calendar; Type: TABLE; Schema: public; Owner: po_user; Tablespace: 
--
 
CREATE TABLE calendar (
    identifier integer NOT NULL,
    users integer NOT NULL,
    start_date timestamp without time zone,
    end_date timestamp without time zone,
    date_of_creation timestamp without time zone,
    remark text
);
 
 
ALTER TABLE public.calendar OWNER TO po_user;
 
--
-- Name: calendar_id_sequence; Type: SEQUENCE; Schema: public; Owner: po_user
--
 
CREATE SEQUENCE calendar_id_sequence
    START WITH 1
    INCREMENT BY 1
    NO MAXVALUE
    NO MINVALUE
    CACHE 1;
 
 
ALTER TABLE public.calendar_id_sequence OWNER TO po_user;
 
--
-- Name: camera; Type: TABLE; Schema: public; Owner: po_user; Tablespace: 
--
 
CREATE TABLE camera (
    identifier integer NOT NULL,
    "type" integer,
    users integer,
    serial_number character varying(20),
    date_of_purchase timestamp without time zone,
    purchased_new character(1),
    access_rights integer NOT NULL,
    CONSTRAINT camera_purchased_new_check CHECK (((purchased_new = 't'::bpchar) OR (purchased_new = 'f'::bpchar)))
);
 
 
ALTER TABLE public.camera OWNER TO po_user;
 
--
-- Name: camera_id_sequence; Type: SEQUENCE; Schema: public; Owner: po_user
--
 
CREATE SEQUENCE camera_id_sequence
    START WITH 1
    INCREMENT BY 1
    NO MAXVALUE
    NO MINVALUE
    CACHE 1;
 
 
ALTER TABLE public.camera_id_sequence OWNER TO po_user;
 
--
-- Name: camera_metering; Type: TABLE; Schema: public; Owner: po_user; Tablespace: 
--
 
CREATE TABLE camera_metering (
    identifier integer NOT NULL,
    value character varying(40)
);
 
 
ALTER TABLE public.camera_metering OWNER TO po_user;
 
--
-- Name: camera_metering_id_sequence; Type: SEQUENCE; Schema: public; Owner: po_user
--
 
CREATE SEQUENCE camera_metering_id_sequence
    INCREMENT BY 1
    NO MAXVALUE
    NO MINVALUE
    CACHE 1;
 
 
ALTER TABLE public.camera_metering_id_sequence OWNER TO po_user;
 
--
-- Name: camera_program; Type: TABLE; Schema: public; Owner: po_user; Tablespace: 
--
 
CREATE TABLE camera_program (
    identifier integer NOT NULL,
    value character varying(40)
);
 
 
ALTER TABLE public.camera_program OWNER TO po_user;
 
--
-- Name: camera_program_id_sequence; Type: SEQUENCE; Schema: public; Owner: po_user
--
 
CREATE SEQUENCE camera_program_id_sequence
    INCREMENT BY 1
    NO MAXVALUE
    NO MINVALUE
    CACHE 1;
 
 
ALTER TABLE public.camera_program_id_sequence OWNER TO po_user;
 
--
-- Name: camera_type; Type: TABLE; Schema: public; Owner: po_user; Tablespace: 
--
 
CREATE TABLE camera_type (
    identifier integer NOT NULL,
    manufacturer integer NOT NULL,
    model character varying(100),
    variation character varying(100),
    last_modified_date timestamp without time zone,
    last_modifying_users integer,
    raw_icc_profile integer
);
 
 
ALTER TABLE public.camera_type OWNER TO po_user;
 
--
-- Name: camera_type_id_sequence; Type: SEQUENCE; Schema: public; Owner: po_user
--
 
CREATE SEQUENCE camera_type_id_sequence
    START WITH 1
    INCREMENT BY 1
    NO MAXVALUE
    NO MINVALUE
    CACHE 1;
 
 
ALTER TABLE public.camera_type_id_sequence OWNER TO po_user;
 
--
-- Name: client; Type: TABLE; Schema: public; Owner: po_user; Tablespace: 
--
 
CREATE TABLE client (
    identifier integer NOT NULL,
    users integer NOT NULL,
    client integer NOT NULL,
    date_of_creation timestamp without time zone,
    STATUS integer NOT NULL,
    "trusted" character(1),
    CONSTRAINT client_trusted_check CHECK ((("trusted" = 't'::bpchar) OR ("trusted" = 'f'::bpchar)))
);
 
 
ALTER TABLE public.client OWNER TO po_user;
 
--
-- Name: client_id_sequence; Type: SEQUENCE; Schema: public; Owner: po_user
--
 
CREATE SEQUENCE client_id_sequence
    START WITH 1
    INCREMENT BY 1
    NO MAXVALUE
    NO MINVALUE
    CACHE 1;
 
 
ALTER TABLE public.client_id_sequence OWNER TO po_user;
 
--
-- Name: client_status; Type: TABLE; Schema: public; Owner: po_user; Tablespace: 
--
 
CREATE TABLE client_status (
    identifier integer NOT NULL,
    value character varying(12)
);
 
 
ALTER TABLE public.client_status OWNER TO po_user;
 
--
-- Name: client_status_id_sequence; Type: SEQUENCE; Schema: public; Owner: po_user
--
 
CREATE SEQUENCE client_status_id_sequence
    INCREMENT BY 1
    NO MAXVALUE
    NO MINVALUE
    CACHE 1;
 
 
ALTER TABLE public.client_status_id_sequence OWNER TO po_user;
 
--
-- Name: contact_info; Type: TABLE; Schema: public; Owner: po_user; Tablespace: 
--
 
CREATE TABLE contact_info (
    identifier integer NOT NULL,
    address1 character varying(100),
    address2 character varying(100),
    city character varying(100),
    zipcode character varying(10),
    state integer,
    country integer,
    phone character varying(40),
    email character varying(150),
    url character varying(150)
);
 
 
ALTER TABLE public.contact_info OWNER TO po_user;
 
--
-- Name: contact_info_id_sequence; Type: SEQUENCE; Schema: public; Owner: po_user
--
 
CREATE SEQUENCE contact_info_id_sequence
    INCREMENT BY 1
    NO MAXVALUE
    NO MINVALUE
    CACHE 1;
 
 
ALTER TABLE public.contact_info_id_sequence OWNER TO po_user;
 
--
-- Name: country; Type: TABLE; Schema: public; Owner: po_user; Tablespace: 
--
 
CREATE TABLE country (
    identifier integer NOT NULL,
    code character varying(5),
    value character varying(40)
);
 
 
ALTER TABLE public.country OWNER TO po_user;
 
--
-- Name: country_id_sequence; Type: SEQUENCE; Schema: public; Owner: po_user
--
 
CREATE SEQUENCE country_id_sequence
    INCREMENT BY 1
    NO MAXVALUE
    NO MINVALUE
    CACHE 1;
 
 
ALTER TABLE public.country_id_sequence OWNER TO po_user;
 
--
-- Name: currency; Type: TABLE; Schema: public; Owner: po_user; Tablespace: 
--
 
CREATE TABLE currency (
    identifier integer NOT NULL,
    numeric_code numeric,
    alpha_code character varying(5),
    name character varying(40),
    entity text
);
 
 
ALTER TABLE public.currency OWNER TO po_user;
 
--
-- Name: currency_id_sequence; Type: SEQUENCE; Schema: public; Owner: po_user
--
 
CREATE SEQUENCE currency_id_sequence
    INCREMENT BY 1
    NO MAXVALUE
    NO MINVALUE
    CACHE 1;
 
 
ALTER TABLE public.currency_id_sequence OWNER TO po_user;
 
--
-- Name: dcraw_options; Type: TABLE; Schema: public; Owner: po_user; Tablespace: 
--
 
CREATE TABLE dcraw_options (
    identifier integer NOT NULL,
    gamma double precision,
    brightness double precision,
    white_balance character varying(10),
    bitdepth integer,
    CONSTRAINT dcraw_options_bitdepth_check CHECK (((bitdepth = 24) OR (bitdepth = 48))),
    CONSTRAINT dcraw_options_white_balance_check CHECK ((((white_balance)::text = 'camera'::text) OR ((white_balance)::text = 'automatic'::text)))
);
 
 
ALTER TABLE public.dcraw_options OWNER TO po_user;
 
--
-- Name: dcraw_options_id_sequence; Type: SEQUENCE; Schema: public; Owner: po_user
--
 
CREATE SEQUENCE dcraw_options_id_sequence
    INCREMENT BY 1
    NO MAXVALUE
    NO MINVALUE
    CACHE 1;
 
 
ALTER TABLE public.dcraw_options_id_sequence OWNER TO po_user;
 
--
-- Name: ev_comp; Type: TABLE; Schema: public; Owner: po_user; Tablespace: 
--
 
CREATE TABLE ev_comp (
    identifier integer NOT NULL,
    value character varying(10)
);
 
 
ALTER TABLE public.ev_comp OWNER TO po_user;
 
--
-- Name: ev_comp_id_sequence; Type: SEQUENCE; Schema: public; Owner: po_user
--
 
CREATE SEQUENCE ev_comp_id_sequence
    INCREMENT BY 1
    NO MAXVALUE
    NO MINVALUE
    CACHE 1;
 
 
ALTER TABLE public.ev_comp_id_sequence OWNER TO po_user;
 
--
-- Name: film; Type: TABLE; Schema: public; Owner: po_user; Tablespace: 
--
 
CREATE TABLE film (
    identifier integer NOT NULL,
    "type" integer NOT NULL,
    users integer NOT NULL,
    access_rights integer NOT NULL
);
 
 
ALTER TABLE public.film OWNER TO po_user;
 
--
-- Name: film_format; Type: TABLE; Schema: public; Owner: po_user; Tablespace: 
--
 
CREATE TABLE film_format (
    identifier integer NOT NULL,
    value character varying(10)
);
 
 
ALTER TABLE public.film_format OWNER TO po_user;
 
--
-- Name: film_format_id_sequence; Type: SEQUENCE; Schema: public; Owner: po_user
--
 
CREATE SEQUENCE film_format_id_sequence
    INCREMENT BY 1
    NO MAXVALUE
    NO MINVALUE
    CACHE 1;
 
 
ALTER TABLE public.film_format_id_sequence OWNER TO po_user;
 
--
-- Name: film_id_sequence; Type: SEQUENCE; Schema: public; Owner: po_user
--
 
CREATE SEQUENCE film_id_sequence
    START WITH 1
    INCREMENT BY 1
    NO MAXVALUE
    NO MINVALUE
    CACHE 1;
 
 
ALTER TABLE public.film_id_sequence OWNER TO po_user;
 
--
-- Name: film_iso; Type: TABLE; Schema: public; Owner: po_user; Tablespace: 
--
 
CREATE TABLE film_iso (
    identifier integer NOT NULL,
    value integer
);
 
 
ALTER TABLE public.film_iso OWNER TO po_user;
 
--
-- Name: film_iso_id_sequence; Type: SEQUENCE; Schema: public; Owner: po_user
--
 
CREATE SEQUENCE film_iso_id_sequence
    INCREMENT BY 1
    NO MAXVALUE
    NO MINVALUE
    CACHE 1;
 
 
ALTER TABLE public.film_iso_id_sequence OWNER TO po_user;
 
--
-- Name: film_type; Type: TABLE; Schema: public; Owner: po_user; Tablespace: 
--
 
CREATE TABLE film_type (
    identifier integer NOT NULL,
    manufacturer integer NOT NULL,
    model character varying(100),
    iso integer NOT NULL,
    format integer NOT NULL,
    last_modified_date timestamp without time zone,
    last_modifying_users integer
);
 
 
ALTER TABLE public.film_type OWNER TO po_user;
 
--
-- Name: film_type_id_sequence; Type: SEQUENCE; Schema: public; Owner: po_user
--
 
CREATE SEQUENCE film_type_id_sequence
    START WITH 1
    INCREMENT BY 1
    NO MAXVALUE
    NO MINVALUE
    CACHE 1;
 
 
ALTER TABLE public.film_type_id_sequence OWNER TO po_user;
 
--
-- Name: filter; Type: TABLE; Schema: public; Owner: po_user; Tablespace: 
--
 
CREATE TABLE filter (
    identifier integer NOT NULL,
    "type" integer NOT NULL,
    users integer NOT NULL,
    date_of_purchase timestamp without time zone,
    purchased_new character(1),
    access_rights integer NOT NULL,
    serial_number character varying(20),
    CONSTRAINT filter_purchased_new_check CHECK (((purchased_new = 't'::bpchar) OR (purchased_new = 'f'::bpchar)))
);
 
 
ALTER TABLE public.filter OWNER TO po_user;
 
--
-- Name: filter_id_sequence; Type: SEQUENCE; Schema: public; Owner: po_user
--
 
CREATE SEQUENCE filter_id_sequence
    START WITH 1
    INCREMENT BY 1
    NO MAXVALUE
    NO MINVALUE
    CACHE 1;
 
 
ALTER TABLE public.filter_id_sequence OWNER TO po_user;
 
--
-- Name: filter_type; Type: TABLE; Schema: public; Owner: po_user; Tablespace: 
--
 
CREATE TABLE filter_type (
    identifier integer NOT NULL,
    manufacturer integer NOT NULL,
    model character varying(100),
    variation character varying(100),
    last_modified_date timestamp without time zone,
    last_modifying_users integer
);
 
 
ALTER TABLE public.filter_type OWNER TO po_user;
 
--
-- Name: filter_type_id_sequence; Type: SEQUENCE; Schema: public; Owner: po_user
--
 
CREATE SEQUENCE filter_type_id_sequence
    START WITH 1
    INCREMENT BY 1
    NO MAXVALUE
    NO MINVALUE
    CACHE 1;
 
 
ALTER TABLE public.filter_type_id_sequence OWNER TO po_user;
 
--
-- Name: flash; Type: TABLE; Schema: public; Owner: po_user; Tablespace: 
--
 
CREATE TABLE flash (
    identifier integer NOT NULL,
    "type" integer NOT NULL,
    users integer NOT NULL,
    serial_number character varying(20),
    date_of_purchase timestamp without time zone,
    purchased_new character(1),
    access_rights integer NOT NULL,
    CONSTRAINT flash_purchased_new_check CHECK (((purchased_new = 't'::bpchar) OR (purchased_new = 'f'::bpchar)))
);
 
 
ALTER TABLE public.flash OWNER TO po_user;
 
--
-- Name: flash_id_sequence; Type: SEQUENCE; Schema: public; Owner: po_user
--
 
CREATE SEQUENCE flash_id_sequence
    START WITH 1
    INCREMENT BY 1
    NO MAXVALUE
    NO MINVALUE
    CACHE 1;
 
 
ALTER TABLE public.flash_id_sequence OWNER TO po_user;
 
--
-- Name: flash_mode; Type: TABLE; Schema: public; Owner: po_user; Tablespace: 
--
 
CREATE TABLE flash_mode (
    identifier integer NOT NULL,
    value character varying(40)
);
 
 
ALTER TABLE public.flash_mode OWNER TO po_user;
 
--
-- Name: flash_mode_id_sequence; Type: SEQUENCE; Schema: public; Owner: po_user
--
 
CREATE SEQUENCE flash_mode_id_sequence
    INCREMENT BY 1
    NO MAXVALUE
    NO MINVALUE
    CACHE 1;
 
 
ALTER TABLE public.flash_mode_id_sequence OWNER TO po_user;
 
--
-- Name: flash_type; Type: TABLE; Schema: public; Owner: po_user; Tablespace: 
--
 
CREATE TABLE flash_type (
    identifier integer NOT NULL,
    manufacturer integer NOT NULL,
    model character varying(100),
    variation character varying(100),
    last_modified_date timestamp without time zone,
    last_modifying_users integer
);
 
 
ALTER TABLE public.flash_type OWNER TO po_user;
 
--
-- Name: flash_type_id_sequence; Type: SEQUENCE; Schema: public; Owner: po_user
--
 
CREATE SEQUENCE flash_type_id_sequence
    START WITH 1
    INCREMENT BY 1
    NO MAXVALUE
    NO MINVALUE
    CACHE 1;
 
 
ALTER TABLE public.flash_type_id_sequence OWNER TO po_user;
 
--
-- Name: focal_length; Type: TABLE; Schema: public; Owner: po_user; Tablespace: 
--
 
CREATE TABLE focal_length (
    identifier integer NOT NULL,
    value integer
);
 
 
ALTER TABLE public.focal_length OWNER TO po_user;
 
--
-- Name: focal_length_id_sequence; Type: SEQUENCE; Schema: public; Owner: po_user
--
 
CREATE SEQUENCE focal_length_id_sequence
    INCREMENT BY 1
    NO MAXVALUE
    NO MINVALUE
    CACHE 1;
 
 
ALTER TABLE public.focal_length_id_sequence OWNER TO po_user;
 
--
-- Name: folder; Type: TABLE; Schema: public; Owner: po_user; Tablespace: 
--
 
CREATE TABLE folder (
    identifier integer NOT NULL,
    parent_folder integer,
    users integer NOT NULL,
    caption text,
    date_of_creation timestamp without time zone,
    access_rights integer NOT NULL,
    orderby integer,
    description text
);
 
 
ALTER TABLE public.folder OWNER TO po_user;
 
--
-- Name: folder_id_sequence; Type: SEQUENCE; Schema: public; Owner: po_user
--
 
CREATE SEQUENCE folder_id_sequence
    INCREMENT BY 1
    NO MAXVALUE
    NO MINVALUE
    CACHE 1;
 
 
ALTER TABLE public.folder_id_sequence OWNER TO po_user;
 
--
-- Name: imagemagick_composite_options; Type: TABLE; Schema: public; Owner: po_user; Tablespace: 
--
 
CREATE TABLE imagemagick_composite_options (
    identifier integer NOT NULL,
    gravity character varying(20),
    watermark integer NOT NULL,
    photo_version integer,
    CONSTRAINT imagemagick_composite_options_gravity_check CHECK ((((((((((((gravity)::text = 'center'::text) OR ((gravity)::text = 'northwest'::text)) OR ((gravity)::text = 'north'::text)) OR ((gravity)::text = 'northeast'::text)) OR ((gravity)::text = 'west'::text)) OR ((gravity)::text = 'center'::text)) OR ((gravity)::text = 'east'::text)) OR ((gravity)::text = 'southwest'::text)) OR ((gravity)::text = 'south'::text)) OR ((gravity)::text = 'southeast'::text)))
);
 
 
ALTER TABLE public.imagemagick_composite_options OWNER TO po_user;
 
--
-- Name: imagemagick_composite_options_id_sequence; Type: SEQUENCE; Schema: public; Owner: po_user
--
 
CREATE SEQUENCE imagemagick_composite_options_id_sequence
    INCREMENT BY 1
    NO MAXVALUE
    NO MINVALUE
    CACHE 1;
 
 
ALTER TABLE public.imagemagick_composite_options_id_sequence OWNER TO po_user;
 
--
-- Name: imagemagick_options; Type: TABLE; Schema: public; Owner: po_user; Tablespace: 
--
 
CREATE TABLE imagemagick_options (
    identifier integer NOT NULL,
    preview_quality integer,
    preview_colorspace character varying(20),
    preview_gamma double precision,
    preview_sharpen_radius double precision,
    preview_sharpen_sigma double precision,
    preview_border_width integer,
    preview_border_height integer,
    preview_border_color character varying(6),
    thumb_quality integer,
    thumb_colorspace character varying(20),
    thumb_gamma double precision,
    thumb_sharpen_radius double precision,
    thumb_sharpen_sigma double precision,
    thumb_border_width integer,
    thumb_border_height integer,
    thumb_border_color character varying(6),
    preview_sharpen_threshold double precision,
    preview_sharpen_amount double precision,
    thumb_sharpen_threshold double precision,
    thumb_sharpen_amount double precision
);
 
 
ALTER TABLE public.imagemagick_options OWNER TO po_user;
 
--
-- Name: imagemagick_options_id_sequence; Type: SEQUENCE; Schema: public; Owner: po_user
--
 
CREATE SEQUENCE imagemagick_options_id_sequence
    INCREMENT BY 1
    NO MAXVALUE
    NO MINVALUE
    CACHE 1;
 
 
ALTER TABLE public.imagemagick_options_id_sequence OWNER TO po_user;
 
--
-- Name: label; Type: TABLE; Schema: public; Owner: po_user; Tablespace: 
--
 
CREATE TABLE label (
    identifier integer NOT NULL,
    users integer,
    manufacturer integer,
    name character varying(300),
    space_x double precision,
    space_y double precision,
    size_x double precision,
    size_y double precision,
    offset_x double precision,
    offset_y double precision,
    COLUMNS double precision,
    "rows" double precision,
    paper integer NOT NULL,
    date_of_creation timestamp without time zone,
    last_modified_date timestamp without time zone
);
 
 
ALTER TABLE public.label OWNER TO po_user;
 
--
-- Name: label_id_sequence; Type: SEQUENCE; Schema: public; Owner: po_user
--
 
CREATE SEQUENCE label_id_sequence
    INCREMENT BY 1
    NO MAXVALUE
    NO MINVALUE
    CACHE 1;
 
 
ALTER TABLE public.label_id_sequence OWNER TO po_user;
 
--
-- Name: lens; Type: TABLE; Schema: public; Owner: po_user; Tablespace: 
--
 
CREATE TABLE lens (
    identifier integer NOT NULL,
    "type" integer NOT NULL,
    users integer NOT NULL,
    serial_number character varying(20),
    date_of_purchase timestamp without time zone,
    purchased_new character(1),
    access_rights integer NOT NULL,
    CONSTRAINT lens_purchased_new_check CHECK (((purchased_new = 't'::bpchar) OR (purchased_new = 'f'::bpchar)))
);
 
 
ALTER TABLE public.lens OWNER TO po_user;
 
--
-- Name: lens_id_sequence; Type: SEQUENCE; Schema: public; Owner: po_user
--
 
CREATE SEQUENCE lens_id_sequence
    START WITH 1
    INCREMENT BY 1
    NO MAXVALUE
    NO MINVALUE
    CACHE 1;
 
 
ALTER TABLE public.lens_id_sequence OWNER TO po_user;
 
--
-- Name: lens_type; Type: TABLE; Schema: public; Owner: po_user; Tablespace: 
--
 
CREATE TABLE lens_type (
    identifier integer NOT NULL,
    manufacturer integer NOT NULL,
    model character varying(100),
    variation character varying(100),
    min_focal_length integer NOT NULL,
    max_focal_length integer NOT NULL,
    min_aperture integer NOT NULL,
    max_aperture integer NOT NULL,
    last_modified_date timestamp without time zone,
    last_modifying_users integer
);
 
 
ALTER TABLE public.lens_type OWNER TO po_user;
 
--
-- Name: lens_type_id_sequence; Type: SEQUENCE; Schema: public; Owner: po_user
--
 
CREATE SEQUENCE lens_type_id_sequence
    START WITH 1
    INCREMENT BY 1
    NO MAXVALUE
    NO MINVALUE
    CACHE 1;
 
 
ALTER TABLE public.lens_type_id_sequence OWNER TO po_user;
 
--
-- Name: location; Type: TABLE; Schema: public; Owner: po_user; Tablespace: 
--
 
CREATE TABLE "location" (
    identifier integer NOT NULL,
    place character varying(300),
    state integer,
    country integer,
    last_modified_date timestamp without time zone,
    users integer,
    city character varying(300),
    latitude character varying(10),
    longitude character varying(10),
    private BOOLEAN NOT NULL
);
 
 
ALTER TABLE public."location" OWNER TO po_user;
 
--
-- Name: location_id_sequence; Type: SEQUENCE; Schema: public; Owner: po_user
--
 
CREATE SEQUENCE location_id_sequence
    START WITH 1
    INCREMENT BY 1
    NO MAXVALUE
    NO MINVALUE
    CACHE 1;
 
 
ALTER TABLE public.location_id_sequence OWNER TO po_user;
 
--
-- Name: manufacturer; Type: TABLE; Schema: public; Owner: po_user; Tablespace: 
--
 
CREATE TABLE manufacturer (
    identifier integer NOT NULL,
    name character varying(100),
    url character varying(100),
    last_modified_date timestamp without time zone,
    last_modifying_users integer
);
 
 
ALTER TABLE public.manufacturer OWNER TO po_user;
 
--
-- Name: manufacturer_id_sequence; Type: SEQUENCE; Schema: public; Owner: po_user
--
 
CREATE SEQUENCE manufacturer_id_sequence
    INCREMENT BY 1
    NO MAXVALUE
    NO MINVALUE
    CACHE 1;
 
 
ALTER TABLE public.manufacturer_id_sequence OWNER TO po_user;
 
--
-- Name: orientations; Type: TABLE; Schema: public; Owner: po_user; Tablespace: 
--
 
CREATE TABLE orientations (
    identifier integer NOT NULL,
    name character varying(100),
    im_transform character varying(100)
);
 
 
ALTER TABLE public.orientations OWNER TO po_user;
 
--
-- Name: orientations_id_sequence; Type: SEQUENCE; Schema: public; Owner: po_user
--
 
CREATE SEQUENCE orientations_id_sequence
    INCREMENT BY 1
    NO MAXVALUE
    NO MINVALUE
    CACHE 1;
 
 
ALTER TABLE public.orientations_id_sequence OWNER TO po_user;
 
--
-- Name: paper; Type: TABLE; Schema: public; Owner: po_user; Tablespace: 
--
 
CREATE TABLE paper (
    identifier integer NOT NULL,
    name character varying(300),
    size_x double precision,
    size_y double precision,
    last_modified_date timestamp without time zone,
    last_modifying_users integer
);
 
 
ALTER TABLE public.paper OWNER TO po_user;
 
--
-- Name: paper_id_sequence; Type: SEQUENCE; Schema: public; Owner: po_user
--
 
CREATE SEQUENCE paper_id_sequence
    INCREMENT BY 1
    NO MAXVALUE
    NO MINVALUE
    CACHE 1;
 
 
ALTER TABLE public.paper_id_sequence OWNER TO po_user;
 
--
-- Name: photo; Type: TABLE; Schema: public; Owner: po_user; Tablespace: 
--
 
CREATE TABLE photo (
    identifier integer NOT NULL,
    users integer NOT NULL,
    folder integer NOT NULL,
    "location" integer NOT NULL,
    caption text,
    date_of_exposure timestamp without time zone,
    access_rights integer NOT NULL,
    views integer,
    copyright_statement text,
    hide_original character(1),
    author text,
    title text,
    caption_writer text,
    category character varying(3),
    credit text,
    source text,
    headline text,
    instructions text,
    transmission_reference text,
    supplemental_category text,
    web_statement text,
    CONSTRAINT photo_hide_original_check CHECK (((hide_original = 't'::bpchar) OR (hide_original = 'f'::bpchar)))
);
 
 
ALTER TABLE public.photo OWNER TO po_user;
 
--
-- Name: photo_dupe; Type: TABLE; Schema: public; Owner: po_user; Tablespace: 
--
 
CREATE TABLE photo_dupe (
    identifier integer NOT NULL,
    "key" integer NOT NULL,
    photo integer NOT NULL,
    date_of_creation timestamp without time zone,
    storage_location character varying(50),
    storage_index character varying(10),
    remark text
);
 
 
ALTER TABLE public.photo_dupe OWNER TO po_user;
 
--
-- Name: photo_dupe_id_sequence; Type: SEQUENCE; Schema: public; Owner: po_user
--
 
CREATE SEQUENCE photo_dupe_id_sequence
    INCREMENT BY 1
    NO MAXVALUE
    NO MINVALUE
    CACHE 1;
 
 
ALTER TABLE public.photo_dupe_id_sequence OWNER TO po_user;
 
--
-- Name: photo_id_sequence; Type: SEQUENCE; Schema: public; Owner: po_user
--
 
CREATE SEQUENCE photo_id_sequence
    INCREMENT BY 1
    NO MAXVALUE
    NO MINVALUE
    CACHE 1;
 
 
ALTER TABLE public.photo_id_sequence OWNER TO po_user;
 
--
-- Name: photo_item; Type: TABLE; Schema: public; Owner: po_user; Tablespace: 
--
 
CREATE TABLE photo_item (
    identifier integer NOT NULL,
    photo integer NOT NULL,
    shop_item integer NOT NULL,
    price numeric,
    currency integer,
    "comment" text,
    date_of_creation timestamp without time zone,
    date_of_last_edit timestamp without time zone,
    deleted character(1),
    CONSTRAINT photo_item_deleted_check CHECK (((deleted = 't'::bpchar) OR (deleted = 'f'::bpchar)))
);
 
 
ALTER TABLE public.photo_item OWNER TO po_user;
 
--
-- Name: photo_item_id_sequence; Type: SEQUENCE; Schema: public; Owner: po_user
--
 
CREATE SEQUENCE photo_item_id_sequence
    START WITH 1
    INCREMENT BY 1
    NO MAXVALUE
    NO MINVALUE
    CACHE 1;
 
 
ALTER TABLE public.photo_item_id_sequence OWNER TO po_user;
 
--
-- Name: photo_keywords; Type: TABLE; Schema: public; Owner: po_user; Tablespace: 
--
 
CREATE TABLE photo_keywords (
    photo integer NOT NULL,
    keyword text NOT NULL
);
 
 
ALTER TABLE public.photo_keywords OWNER TO po_user;
 
--
-- Name: photo_spooler; Type: TABLE; Schema: public; Owner: po_user; Tablespace: 
--
 
CREATE TABLE photo_spooler (
    identifier integer NOT NULL,
    users integer,
    photo integer
);
 
 
ALTER TABLE public.photo_spooler OWNER TO po_user;
 
--
-- Name: photo_spooler_id_sequence; Type: SEQUENCE; Schema: public; Owner: po_user
--
 
CREATE SEQUENCE photo_spooler_id_sequence
    START WITH 1
    INCREMENT BY 1
    NO MAXVALUE
    NO MINVALUE
    CACHE 1;
 
 
ALTER TABLE public.photo_spooler_id_sequence OWNER TO po_user;
 
--
-- Name: photo_tech; Type: TABLE; Schema: public; Owner: po_user; Tablespace: 
--
 
CREATE TABLE photo_tech (
    identifier integer NOT NULL,
    photo integer NOT NULL,
    camera integer,
    lens integer,
    film integer,
    flash integer,
    scanner integer,
    filter integer,
    scan_resolution integer,
    aperture integer,
    focal_length integer,
    shutter integer,
    camera_metering integer,
    camera_program integer,
    flash_mode integer,
    exposure_comp integer,
    flash_comp integer,
    ev_difference integer,
    iso_override integer,
    support integer,
    scan_bitdepth integer,
    scan_multiscan integer,
    exif text,
    iptc text
);
 
 
ALTER TABLE public.photo_tech OWNER TO po_user;
 
--
-- Name: photo_tech_id_sequence; Type: SEQUENCE; Schema: public; Owner: po_user
--
 
CREATE SEQUENCE photo_tech_id_sequence
    INCREMENT BY 1
    NO MAXVALUE
    NO MINVALUE
    CACHE 1;
 
 
ALTER TABLE public.photo_tech_id_sequence OWNER TO po_user;
 
--
-- Name: photo_version; Type: TABLE; Schema: public; Owner: po_user; Tablespace: 
--
 
CREATE TABLE photo_version (
    identifier integer NOT NULL,
    "key" integer NOT NULL,
    photo integer NOT NULL,
    master character(1),
    small_image_path character varying(500),
    medium_image_path character varying(500),
    large_image_path character varying(500),
    date_of_creation timestamp without time zone,
    "comment" text,
    original_image_name character varying(500),
    colorspace integer NOT NULL,
    orientation integer NOT NULL,
    CONSTRAINT photo_version_master_check CHECK (((master = 't'::bpchar) OR<