/**
* @function accept_agreement
* @memberof auth
* @description Accept agreement
* @param {integer} PersonId
* @returns {void}
*/
function accept_agreement() {
/*
CREATE OR REPLACE FUNCTION auth.accept_agreement("PersonId" integer)
RETURNS void
LANGUAGE plpgsql
AS $function$
BEGIN
UPDATE auth.person p SET agreed = now() WHERE id = "PersonId";
END $function$
*/
}
/**
* @function create_context
* @memberof auth
* @description Create context of the user
* @param {uuid} UserId
* @param {integer} LangId
* @param {integer} AppId
* @param {uuid} ImpersonatedUserId
* @returns {void}
*/
function create_context() {
/*
CREATE OR REPLACE FUNCTION auth.create_context("UserId" uuid, "LangId" integer, "AppId" integer, "ImpersonatedUserId" uuid DEFAULT NULL::uuid)
RETURNS void
LANGUAGE plpgsql
AS $function$ BEGIN
PERFORM set_config('context.user_id', "UserId"::text, false);
PERFORM set_config('context.impersonated_user_id', "ImpersonatedUserId"::text, false);
PERFORM set_config('context.lang_id', "LangId"::text, false);
PERFORM set_config('context.app_id', "AppId"::text, false);
END $function$
*/
}
/**
* @function create_public_context
* @memberof auth
* @description Create public context
* @param {integer} PersonId
* @param {integer} LangId
* @returns {void}
*/
function create_public_context() {
/*
CREATE OR REPLACE FUNCTION auth.create_public_context("PersonId" integer, "LangId" integer, "IsAdmin" boolean)
RETURNS void
LANGUAGE plpgsql
AS $function$ BEGIN
PERFORM set_config('context.person_id', "PersonId"::text, false);
PERFORM set_config('context.lang_id', "LangId"::text, false);
PERFORM set_config('context.is_admin', "IsAdmin"::text, false);
END $function$
*/
}
/**
* @function create_user
* @memberof auth
* @description Create user of auxiliary backoffice app
* @param {integer} PersonId
* @returns {void}
*/
function create_user() {
/*
CREATE OR REPLACE FUNCTION auth.create_user("PersonId" integer)
RETURNS void
LANGUAGE plpgsql
AS $function$
DECLARE v_user_id UUID;
BEGIN
INSERT INTO auth.user (user_name, first_name, last_name, email)
SELECT email, first_name, last_name, email
FROM auth.person
WHERE id = "PersonId"
RETURNING id INTO v_user_id;
UPDATE auth.person SET user_id = v_user_id
WHERE id = "PersonId";
END $function$
*/
}
/**
* @function get_context_app_id
* @memberof auth
* @description Get app id from the context
* @returns {integer}
*/
function get_context_app_id() {
/*
CREATE OR REPLACE FUNCTION auth.get_context_app_id()
RETURNS integer
LANGUAGE plpgsql
AS $function$ BEGIN
RETURN current_setting('context.app_id', true)::INTEGER;
END $function$
*/
}
/**
* @function get_context_is_admin
* @memberof auth
* @description Get is admin from the context
* @returns {integer}
*/
function get_context_is_admin() {
/*
CREATE OR REPLACE FUNCTION auth.get_context_is_admin()
RETURNS boolean
LANGUAGE plpgsql
AS $function$ BEGIN
RETURN current_setting('context.is_admin', true)::boolean;
END $function$
*/
}
/**
* @function get_context_lang_id
* @memberof auth
* @description Get lang id from the context
* @returns {integer}
*/
function get_context_lang_id() {
/*
CREATE OR REPLACE FUNCTION auth.get_context_lang_id()
RETURNS integer
LANGUAGE plpgsql
AS $function$
BEGIN
RETURN current_setting('context.lang_id', true)::INTEGER;
END $function$
*/
}
/**
* @function get_context_person_id
* @memberof auth
* @description Get person id from the context
* @returns {integer}
*/
function get_context_person_id() {
/*
CREATE OR REPLACE FUNCTION auth.get_context_person_id()
RETURNS integer
LANGUAGE plpgsql
AS $function$
DECLARE v_person_id varchar;
BEGIN
v_person_id := current_setting('context.person_id', true);
IF v_person_id = '' THEN
RETURN NULL;
ELSE
RETURN v_person_id::int;
END IF;
END $function$
*/
}
/**
* @function get_context_tenant_id
* @memberof auth
* @description Get tenant id from the context
* @returns {integer}
*/
function get_context_tenant_id() {
/*
CREATE OR REPLACE FUNCTION auth.get_context_tenant_id()
RETURNS integer
LANGUAGE plpgsql
AS $function$
BEGIN
RETURN (
SELECT tenant_id
FROM meta.app
WHERE id = current_setting('context.app_id')::INTEGER
);
END $function$
*/
}
/**
* @function get_context_user_id
* @memberof auth
* @description Get user id from the context
* @returns {uuid}
*/
function get_context_user_id() {
/*
CREATE OR REPLACE FUNCTION auth.get_context_user_id()
RETURNS uuid
LANGUAGE plpgsql
AS $function$ BEGIN
RETURN current_setting('context.user_id', true)::UUID;
END $function$
*/
}
/**
* @function get_context_user_id_for_data
* @memberof auth
* @description Get user id of the impersonated user from the context
* @returns {uuid}
*/
function get_context_user_id_for_data() {
/*
CREATE OR REPLACE FUNCTION auth.get_context_user_id_for_data()
RETURNS uuid
LANGUAGE plpgsql
AS $function$
DECLARE v_id TEXT;
BEGIN
v_id := current_setting('context.impersonated_user_id');
IF v_id = '' THEN
RETURN null::UUID;
ELSE
RETURN v_id::UUID;
END IF;
END $function$
*/
}
/**
* @function get_event_dates
* @memberof auth
* @description Get event dates
* @param {integer} TenantId
* @param {integer} PeriodId
* @param {integer} AppId
* @returns {Object}
* @property {uuid} event_id
* @property {timestamp_without_time_zone} datetime
*/
function get_event_dates() {
/*
CREATE OR REPLACE FUNCTION auth.get_event_dates("TenantId" integer DEFAULT NULL::integer, "PeriodId" integer DEFAULT NULL::integer, "AppId" integer DEFAULT NULL::integer)
RETURNS TABLE(event_id uuid, datetime timestamp without time zone)
LANGUAGE plpgsql
AS $function$
BEGIN
RETURN QUERY
SELECT DISTINCT ed.event_id, ed.datetime
FROM auth.event_date AS ed
JOIN auth.event e ON e.id = ed.event_id
WHERE (e.tenant_id = "TenantId" OR "TenantId" IS NULL)
AND ed.period_id = "PeriodId" AND e.app_id = "AppId";
END $function$
*/
}
/**
* @function get_or_create_person_id
* @memberof auth
* @description Get or create person id - registers new user if not already registered
* @param {character_varying} Email
* @param {character_varying} FirstName
* @param {character_varying} LastName
* @returns {integer}
*/
function get_or_create_person_id() {
/*
CREATE OR REPLACE FUNCTION auth.get_or_create_person_id("Email" character varying, "FirstName" character varying, "LastName" character varying)
RETURNS json
LANGUAGE plpgsql
AS $function$
DECLARE v_id INT;
v_isadmin BOOLEAN;
BEGIN
-- Routine body goes here...
SELECT p.id, CASE WHEN r.id IS NOT NULL THEN true ELSE false END is_admin INTO v_id, v_isadmin
FROM auth.person p
LEFT JOIN auth.person_role r ON r.person_id = p.id AND r.role_id = 1
WHERE p.user_email = "Email";
IF v_id IS NULL THEN
INSERT INTO auth.person (user_email, first_name, last_name)
VALUES ("Email", "FirstName", "LastName")
RETURNING id INTO v_id;
v_isadmin := false;
END IF;
RETURN json_build_object('id', v_id, 'is_admin', v_isadmin);
END $function$
*/
}
/**
* @function get_users
* @memberof auth
* @description Get users
* @returns {json}
*/
function get_users() {
/*
CREATE OR REPLACE FUNCTION auth.get_users()
RETURNS json
LANGUAGE plpgsql
AS $function$
BEGIN
IF NOT EXISTS (
SELECT 1 FROM auth.person p
INNER JOIN auth.person_role r ON r.person_id = p.id and r.role_id = 1
WHERE p.id = auth.get_context_person_id()) THEN
RAISE EXCEPTION 'Not allowed';
END IF;
RETURN (
SELECT json_agg(t.*) FROM (
SELECT id value, p.last_name || ', ' || p.first_name || ' (' || COALESCE(p.user_email, p.email, '?') || ') ' label, left(p.first_name, 1) || left(p.last_name, 1) short_display_value --, p.last_name || ', ' || p.first_name display_value
FROM auth.person p
ORDER BY 2
) t
);
END $function$
*/
}
/**
* @function login
* @memberof auth
* @description Records a login event and returns the person record.
* @param {integer} PersonId
* @param {character_varying} IP
* @returns {json}
*/
function login() {
/*
CREATE OR REPLACE FUNCTION auth.login("PersonId" integer, "IP" character varying, "Ref" character varying)
RETURNS json
LANGUAGE plpgsql
AS $function$
BEGIN
INSERT INTO auth.log(person_id, ip)
VALUES ("PersonId", "IP");
RETURN (
SELECT row_to_json(t) FROM (
SELECT t.*, CASE WHEN r.id IS NOT NULL THEN true ELSE false END is_admin
FROM auth.person t
LEFT JOIN auth.person_role r ON r.person_id = t.id AND r.role_id = 1
WHERE t.id = "PersonId"
) t
);
END $function$
*/
}
/**
* @function person_role_history
* @memberof auth
* @description Person role public history trigger function
* @returns {trigger}
*/
function person_role_history() {
/*
CREATE OR REPLACE FUNCTION auth.person_role_history()
RETURNS trigger
LANGUAGE plpgsql
AS $function$
DECLARE v_person_id INT;
v_user_id UUID;
BEGIN
v_person_id := auth.get_context_person_id();
v_user_id := auth.get_context_user_id();
IF TG_OP = 'DELETE' THEN
INSERT INTO zzHistory.auth_person_role (
id,
person_id,
role_id,
ModifiedUserId,
ModifiedPersonId,
ModifiedTime,
ModifiedLogin,
ModifiedAction
)
SELECT OLD.id,
OLD.person_id,
OLD.role_id,
v_user_id,
v_person_id,
CURRENT_TIMESTAMP,
CURRENT_USER,
'D';
ELSE
INSERT INTO zzHistory.auth_person_role (
id,
person_id,
role_id,
ModifiedUserId,
ModifiedPersonId,
ModifiedTime,
ModifiedLogin,
ModifiedAction
)
SELECT NEW.id,
NEW.person_id,
NEW.role_id,
v_user_id,
v_person_id,
CURRENT_TIMESTAMP,
CURRENT_USER,
CASE WHEN TG_OP = 'INSERT' THEN 'I' ELSE 'U' END;
END IF;
RETURN NULL;
END $function$
*/
}
/**
* @function role_history
* @memberof auth
* @description Role public history trigger function
* @returns {trigger}
*/
function role_history() {
/*
CREATE OR REPLACE FUNCTION auth.role_history()
RETURNS trigger
LANGUAGE plpgsql
AS $function$
DECLARE v_person_id INT;
v_user_id UUID;
BEGIN
v_person_id := auth.get_context_person_id();
v_user_id := auth.get_context_user_id();
IF TG_OP = 'DELETE' THEN
INSERT INTO zzHistory.auth_role (
id,
name,
ModifiedUserId,
ModifiedPersonId,
ModifiedTime,
ModifiedLogin,
ModifiedAction
)
SELECT OLD.id,
OLD.name,
v_user_id,
v_person_id,
CURRENT_TIMESTAMP,
CURRENT_USER,
'D';
ELSE
INSERT INTO zzHistory.auth_role (
id,
name,
ModifiedUserId,
ModifiedPersonId,
ModifiedTime,
ModifiedLogin,
ModifiedAction
)
SELECT NEW.id,
NEW.name,
v_user_id,
v_person_id,
CURRENT_TIMESTAMP,
CURRENT_USER,
CASE WHEN TG_OP = 'INSERT' THEN 'I' ELSE 'U' END;
END IF;
RETURN NULL;
END $function$
*/
}
/**
* @function route_role_history
* @memberof auth
* @description Route role public history trigger function
* @returns {trigger}
*/
function route_role_history() {
/*
CREATE OR REPLACE FUNCTION auth.route_role_history()
RETURNS trigger
LANGUAGE plpgsql
AS $function$
DECLARE v_person_id INT;
v_user_id UUID;
BEGIN
v_person_id := auth.get_context_person_id();
v_user_id := auth.get_context_user_id();
IF TG_OP = 'DELETE' THEN
INSERT INTO zzHistory.auth_route_role (
id,
route_id,
role_id,
ModifiedUserId,
ModifiedPersonId,
ModifiedTime,
ModifiedLogin,
ModifiedAction
)
SELECT OLD.id,
OLD.route_id,
OLD.role_id,
v_user_id,
v_person_id,
CURRENT_TIMESTAMP,
CURRENT_USER,
'D';
ELSE
INSERT INTO zzHistory.auth_route_role (
id,
route_id,
role_id,
ModifiedUserId,
ModifiedPersonId,
ModifiedTime,
ModifiedLogin,
ModifiedAction
)
SELECT NEW.id,
NEW.route_id,
NEW.role_id,
v_user_id,
v_person_id,
CURRENT_TIMESTAMP,
CURRENT_USER,
CASE WHEN TG_OP = 'INSERT' THEN 'I' ELSE 'U' END;
END IF;
RETURN NULL;
END $function$
*/
}
/**
* @function import_environmental_zone
* @memberof catalog
* @description Import environmental zone
* @param {text} Params
* @param {text} Json
* @returns {void}
*/
function import_environmental_zone() {
/*
CREATE OR REPLACE FUNCTION catalog.import_environmental_zone("Params" text, "Json" text)
RETURNS void
LANGUAGE plpgsql
AS $function$
BEGIN
DROP TABLE IF EXISTS q;
CREATE TEMP TABLE q AS
SELECT * FROM json_to_recordset("Json"::json) AS J("Name" varchar, "Code" varchar);
DROP TABLE IF EXISTS t;
CREATE TEMP TABLE t AS
SELECT q.* FROM q
;
WITH x AS (SELECT DISTINCT t."Name", t."Code" FROM t)
INSERT INTO catalog.environmental_zone(name, code)
SELECT meta.clean_value(x."Name", 'varchar')::varchar, meta.clean_value(x."Code", 'varchar')::varchar FROM x
LEFT JOIN catalog.environmental_zone environmental_zone ON environmental_zone.name= x."Name"::varchar
WHERE environmental_zone.id IS NULL;
END $function$
*/
}
/**
* @function import_soil_type
* @memberof catalog
* @description Import soil type
* @param {text} Json
* @param {text} Params
* @returns {void}
*/
function import_soil_type() {
/*
CREATE OR REPLACE FUNCTION catalog.import_soil_type("Params" text, "Json" text)
RETURNS void
LANGUAGE plpgsql
AS $function$
BEGIN
DROP TABLE IF EXISTS q;
CREATE TEMP TABLE q AS
SELECT * FROM json_to_recordset("Json"::json) AS J("code" varchar, "name" varchar);
DROP TABLE IF EXISTS t;
CREATE TEMP TABLE t AS
SELECT q.* FROM q
;
WITH x AS (SELECT DISTINCT t."code", t."name" FROM t)
INSERT INTO catalog.soil_type(code, name)
SELECT meta.clean_value(x."code", 'varchar')::varchar, meta.clean_value(x."name", 'varchar')::varchar FROM x
LEFT JOIN catalog.soil_type soil_type ON soil_type.code= x."code"::varchar
WHERE soil_type.id IS NULL;
END $function$
*/
}
/**
* @function copy_color_scheme
* @memberof data
* @description Copy color scheme from one indicator to another
* @param {integer} IndicatorIdFrom
* @param {integer} IndicatorIdTo
* @returns {void}
*/
function copy_color_scheme() {
/*
CREATE OR REPLACE FUNCTION data.copy_color_scheme("IndicatorIdFrom" integer, "IndicatorIdTo" integer)
RETURNS void
LANGUAGE plpgsql
AS $function$
BEGIN
INSERT INTO data.indicator_color (indicator_id, value_to, color_id)
SELECT "IndicatorIdTo", value_to, color_id
FROM data.indicator_color c
WHERE indicator_id = "IndicatorIdFrom";
END $function$
*/
}
/**
* @function data_asset_import_excel
* @memberof data
* @description Data asset import from excel function
* @param {text} jsonCV
* @param {text} jsonData
* @returns {void}
*/
function data_asset_import_excel() {
/*
CREATE OR REPLACE FUNCTION data.data_asset_import_excel("jsonCV" text, "jsonData" text)
RETURNS void
LANGUAGE plpgsql
AS $function$
BEGIN
DROP TABLE IF EXISTS t;
CREATE TEMP TABLE t AS
SELECT * FROM json_to_recordset("jsonData"::json) AS J(
"id" varchar, "ignore" varchar, "catalog" varchar, "title" varchar, "description" varchar, "Theme" varchar, "keywords_list" varchar, "version" varchar, "doi" varchar, "layer_unit" varchar, "scale_factor" varchar, "contact_name" varchar, "contact_email" varchar, "providers_list" varchar, "license" varchar, "constellation_list" varchar, "platform" varchar, "instruments_list" varchar, "gsd" varchar, "start_date" varchar, "end_date" varchar, "date_step" varchar, "date_offset" varchar, "date_unit" varchar, "date_style" varchar, "ignore_29feb" varchar, "depth_list" varchar, "main_sld_url" varchar, "sld_1_url" varchar, "main_qml_url" varchar, "main_url" varchar, "url_1" varchar, "url_2" varchar, "url_3" varchar, "url_4" varchar, "url_5" varchar, "url_6" varchar, "url_7" varchar, "url_8" varchar, "url_9" varchar, "url_10" varchar, "url_11" varchar, "url_12" varchar, "url_13" varchar, "url_14" varchar, "url_15" varchar, "url_16" varchar, "url_17" varchar, "url_18" varchar, "url_19" varchar, "url_20" varchar, "url_21" varchar, "url_22" varchar, "url_23" varchar, "url_24" varchar);
WITH x AS (SELECT DISTINCT t."catalog" FROM t)
INSERT INTO data.asset_catalog(name)
SELECT meta.clean_value(x."catalog", 'varchar')::varchar FROM x
LEFT JOIN data.asset_catalog asset_catalog ON asset_catalog.name= x."catalog"
WHERE asset_catalog.id IS NULL;
WITH x AS (SELECT DISTINCT t."Theme" FROM t)
INSERT INTO data.asset_theme(name)
SELECT meta.clean_value(x."Theme", 'varchar')::varchar FROM x
LEFT JOIN data.asset_theme asset_theme ON asset_theme.name= x."Theme"
WHERE asset_theme.id IS NULL;
WITH x AS (SELECT DISTINCT t."version" FROM t)
INSERT INTO data.asset_version(name)
SELECT meta.clean_value(x."version", 'varchar')::varchar FROM x
LEFT JOIN catalog.asset_version asset_version ON asset_version.name= x."version"
WHERE asset_version.id IS NULL;
WITH x AS (SELECT DISTINCT t."date_style" FROM t)
INSERT INTO data.date_style(name)
SELECT meta.clean_value(x."date_style", 'varchar')::varchar FROM x
LEFT JOIN data.date_style date_style ON date_style.name= x."date_style"
WHERE date_style.id IS NULL;
WITH x AS (SELECT DISTINCT t."date_unit" FROM t)
INSERT INTO data.date_unit(name)
SELECT meta.clean_value(x."date_unit", 'varchar')::varchar FROM x
LEFT JOIN data.date_unit date_unit ON date_unit.name= x."date_unit"
WHERE date_unit.id IS NULL;
WITH x AS (SELECT DISTINCT t."license" FROM t)
INSERT INTO data.license(name)
SELECT meta.clean_value(x."license", 'varchar')::varchar FROM x
LEFT JOIN data.license license ON license.name= x."license"
WHERE license.id IS NULL;
WITH x AS (SELECT DISTINCT t."layer_unit" FROM t)
INSERT INTO data.unit(name)
SELECT meta.clean_value(x."layer_unit", 'varchar')::varchar FROM x
LEFT JOIN catalog.unit unit ON unit.name= x."layer_unit"
WHERE unit.id IS NULL;
WITH x AS (SELECT DISTINCT t."contact_name" FROM t)
INSERT INTO general.person(name1)
SELECT meta.clean_value(x."contact_name", 'varchar')::varchar FROM x
LEFT JOIN auth.person person ON person.name1= x."contact_name"
WHERE person.id IS NULL;
WITH x AS (SELECT DISTINCT t."id", t."ignore", t."catalog", t."title", t."description", t."Theme", t."keywords_list", t."version", t."doi", t."layer_unit", t."scale_factor", t."contact_name", t."providers_list", t."license", t."constellation_list", t."platform", t."instruments_list", t."gsd", t."start_date", t."end_date", t."date_step", t."date_offset", t."date_unit", t."date_style", t."ignore_29feb", t."depth_list", t."main_sld_url", t."sld_1_url", t."main_qml_url", t."main_url" FROM t)
INSERT INTO data.asset(orig_id, ignore, asset_catalog_id, title, description, asset_theme_id, keywords_list, asset_version_id, doi, unit_id, scale_factor, person_id, providers_list, license_id, constellation_list, platform, instruments_list, gsd, start_date, end_date, date_step, date_offset, date_unit_id, date_style_id, ignore_29feb, depth_list, main_sld_url, sld_1_url, main_qml_url, main_url)
SELECT meta.clean_value(x."id", 'varchar')::varchar, meta.clean_value(x."ignore", 'boolean')::boolean, asset_catalog.id, meta.clean_value(x."title", 'varchar')::varchar, meta.clean_value(x."description", 'varchar')::varchar, asset_theme.id, meta.clean_value(x."keywords_list", 'varchar')::varchar, asset_version.id, meta.clean_value(x."doi", 'varchar')::varchar, unit.id, meta.clean_value(x."scale_factor", 'varchar')::varchar, person.id, meta.clean_value(x."providers_list", 'varchar')::varchar, license.id, meta.clean_value(x."constellation_list", 'varchar')::varchar, meta.clean_value(x."platform", 'varchar')::varchar, meta.clean_value(x."instruments_list", 'varchar')::varchar, meta.clean_value(x."gsd", 'varchar')::varchar, meta.clean_value(x."start_date", 'date')::date, meta.clean_value(x."end_date", 'date')::date, meta.clean_value(x."date_step", 'int')::int, meta.clean_value(x."date_offset", 'varchar')::varchar, date_unit.id, date_style.id, meta.clean_value(x."ignore_29feb", 'boolean')::boolean, meta.clean_value(x."depth_list", 'varchar')::varchar, meta.clean_value(x."main_sld_url", 'varchar')::varchar, meta.clean_value(x."sld_1_url", 'varchar')::varchar, meta.clean_value(x."main_qml_url", 'varchar')::varchar, meta.clean_value(x."main_url", 'varchar')::varchar FROM x
LEFT JOIN data.asset asset ON asset.orig_id= x."id"
LEFT JOIN data.asset_catalog asset_catalog ON asset_catalog.name = x."catalog"
LEFT JOIN data.asset_theme asset_theme ON asset_theme.name = x."Theme"
LEFT JOIN catalog.asset_version asset_version ON asset_version.name = x."version"
LEFT JOIN catalog.unit unit ON unit.name = x."layer_unit"
LEFT JOIN auth.person person ON person.name1 = x."contact_name"
LEFT JOIN data.license license ON license.name = x."license"
LEFT JOIN data.date_unit date_unit ON date_unit.name = x."date_unit"
LEFT JOIN data.date_style date_style ON date_style.name = x."date_style"
WHERE asset.id IS NULL;
END $function$
*/
}
/**
* @function data_file_metadata_import_excel
* @memberof data
* @description Data file metadata import from excel function
* @param {text} jsonCV
* @param {text} jsonData
* @returns {void}
*/
function data_file_metadata_import_excel() {
/*
CREATE OR REPLACE FUNCTION data.data_file_metadata_import_excel("jsonCV" text, "jsonData" text)
RETURNS void
LANGUAGE plpgsql
AS $function$
BEGIN
DROP TABLE IF EXISTS t;
CREATE TEMP TABLE t AS
SELECT * FROM json_to_recordset("jsonData"::json) AS J(
"id" varchar, "filename_pattern" varchar, "uncertainty" varchar, "gs_name" varchar, "code" varchar, "title" varchar, "style" varchar, "type" varchar, "category" varchar, "description" varchar, "theme" varchar, "theme_number" varchar, "range" varchar, "range_wasabi" varchar, "fourd_range" varchar, "scale" varchar, "unit" varchar, "has_points" varchar, "sd_type" varchar, "scale_factor" varchar, "gn_url" varchar, "wasabi_link" varchar, "gn_uuid" varchar, "gn_author" varchar, "gn_resolution" varchar, "gn_author_email" varchar, "pub_date" varchar, "dataset_id" varchar, "stac_url" varchar);
WITH x AS (SELECT DISTINCT t."category" FROM t)
INSERT INTO data.file_category(name)
SELECT meta.clean_value(x."category", 'varchar')::varchar FROM x
LEFT JOIN data.file_category file_category ON file_category.name= x."category"
WHERE file_category.id IS NULL;
WITH x AS (SELECT DISTINCT t."dataset_id" FROM t)
INSERT INTO data.file_dataset(name)
SELECT meta.clean_value(x."dataset_id", 'varchar')::varchar FROM x
LEFT JOIN data.file_dataset file_dataset ON file_dataset.name= x."dataset_id"
WHERE file_dataset.id IS NULL;
WITH x AS (SELECT DISTINCT t."gn_resolution" FROM t)
INSERT INTO data.file_resolution(name)
SELECT meta.clean_value(x."gn_resolution", 'varchar')::varchar FROM x
LEFT JOIN data.file_resolution file_resolution ON file_resolution.name= x."gn_resolution"
WHERE file_resolution.id IS NULL;
WITH x AS (SELECT DISTINCT t."scale" FROM t)
INSERT INTO data.file_scale(name)
SELECT meta.clean_value(x."scale", 'varchar')::varchar FROM x
LEFT JOIN data.file_scale file_scale ON file_scale.name= x."scale"
WHERE file_scale.id IS NULL;
WITH x AS (SELECT DISTINCT t."sd_type" FROM t)
INSERT INTO data.file_sd_type(name)
SELECT meta.clean_value(x."sd_type", 'varchar')::varchar FROM x
LEFT JOIN data.file_sd_type file_sd_type ON file_sd_type.name= x."sd_type"
WHERE file_sd_type.id IS NULL;
WITH x AS (SELECT DISTINCT t."theme" FROM t)
INSERT INTO data.file_theme(name)
SELECT meta.clean_value(x."theme", 'varchar')::varchar FROM x
LEFT JOIN data.file_theme file_theme ON file_theme.name= x."theme"
WHERE file_theme.id IS NULL;
WITH x AS (SELECT DISTINCT t."type" FROM t)
INSERT INTO data.file_type(name)
SELECT meta.clean_value(x."type", 'varchar')::varchar FROM x
LEFT JOIN data.file_type file_type ON file_type.name= x."type"
WHERE file_type.id IS NULL;
CREATE TEMP TABLE temp_person AS
SELECT "id", TRIM(s) gn_author FROM t
CROSS JOIN LATERAL string_to_table("gn_author", ',') s;
WITH x AS (SELECT DISTINCT t."gn_author" FROM temp_person t)
INSERT INTO general.person(name1)
SELECT meta.clean_value(x."gn_author", 'varchar')::varchar FROM x
LEFT JOIN auth.person person ON person.name1= x."gn_author"
WHERE person.id IS NULL;
WITH x AS (SELECT DISTINCT t."unit" FROM t)
INSERT INTO general.unit(name)
SELECT meta.clean_value(x."unit", 'varchar')::varchar FROM x
LEFT JOIN general.unit unit ON unit.name= x."unit"
WHERE unit.id IS NULL;
WITH x AS (SELECT DISTINCT t."id", t."filename_pattern", t."uncertainty", t."gs_name", t."code", t."title", t."style", t."type", t."category", t."description", t."theme", t."theme_number", t."range", t."range_wasabi", t."fourd_range", t."scale", t."unit", t."has_points", t."sd_type", t."scale_factor", t."gn_url", t."wasabi_link", t."gn_uuid", t."gn_resolution", t."pub_date", t."dataset_id", t."stac_url" FROM t)
INSERT INTO data.file_metadata(orig_id, filename_pattern, uncertainty, gs_name, code, title, style, file_type_id, file_category_id, description, file_theme_id, theme_number, range, range_wasabi, fourd_range, file_scale_id, unit_id, has_points, file_sd_type_id, scale_factor, gn_url, wasabi_link, gn_uuid, file_resolution_id, pub_date, file_dataset_id, stac_url)
SELECT meta.clean_value(x."id", 'varchar')::varchar, meta.clean_value(x."filename_pattern", 'varchar')::varchar, meta.clean_value(x."uncertainty", 'boolean')::boolean, meta.clean_value(x."gs_name", 'varchar')::varchar, meta.clean_value(x."code", 'text')::text, meta.clean_value(x."title", 'varchar')::varchar, meta.clean_value(x."style", 'varchar')::varchar, file_type.id, file_category.id, meta.clean_value(x."description", 'varchar')::varchar, file_theme.id, meta.clean_value(x."theme_number", 'double precision')::double precision, meta.clean_value(x."range", 'varchar')::varchar, meta.clean_value(x."range_wasabi", 'varchar')::varchar, meta.clean_value(x."fourd_range", 'varchar')::varchar, file_scale.id, unit.id, meta.clean_value(x."has_points", 'boolean')::boolean, file_sd_type.id, meta.clean_value(x."scale_factor", 'varchar')::varchar, meta.clean_value(x."gn_url", 'varchar')::varchar, meta.clean_value(x."wasabi_link", 'varchar')::varchar, meta.clean_value(x."gn_uuid", 'varchar')::varchar, file_resolution.id, meta.clean_value(x."pub_date", 'timestamp')::timestamp, file_dataset.id, meta.clean_value(x."stac_url", 'varchar')::varchar FROM x
LEFT JOIN data.file_metadata file_metadata ON file_metadata.orig_id= x."id"
LEFT JOIN data.file_type file_type ON file_type.name = x."type"
LEFT JOIN data.file_category file_category ON file_category.name = x."category"
LEFT JOIN data.file_theme file_theme ON file_theme.name = x."theme"
LEFT JOIN data.file_scale file_scale ON file_scale.name = x."scale"
LEFT JOIN general.unit unit ON unit.name = x."unit"
LEFT JOIN data.file_sd_type file_sd_type ON file_sd_type.name = x."sd_type"
LEFT JOIN data.file_resolution file_resolution ON file_resolution.name = x."gn_resolution"
LEFT JOIN data.file_dataset file_dataset ON file_dataset.name = x."dataset_id"
WHERE file_metadata.id IS NULL;
INSERT INTO data.file_metadata_person (file_metadata_id, person_id )
SELECT m.id, d.id FROM temp_person x
INNER JOIN data.file_metadata m ON m."orig_id" = x."id"
INNER JOIN auth.person d ON d.name1 = x."gn_author"
LEFT JOIN data.file_metadata_person l ON l.file_metadata_id = m.id AND l.person_id = d.id
WHERE l.id IS NULL;
END $function$
*/
}
/**
* @function data_point_import_excel
* @memberof data
* @description Data point import from excel function
* @param {text} jsonCV
* @param {text} jsonData
* @returns {void}
*/
function data_point_import_excel() {
/*
CREATE OR REPLACE FUNCTION data.data_point_import_excel("jsonCV" text, "jsonData" text)
RETURNS void
LANGUAGE plpgsql
AS $function$
BEGIN
DROP TABLE IF EXISTS t;
CREATE TEMP TABLE t AS
SELECT * FROM json_to_recordset("jsonData"::json) AS J(
"Depth" varchar, "POINTID" varchar, "pH_CaCl2" varchar, "pH_H2O" varchar, "EC" varchar, "OC" varchar, "CaCO3" varchar, "P" varchar, "N" varchar, "K" varchar, "OC (20-30 cm)" varchar, "CaCO3 (20-30 cm)" varchar, "Ox_Al" varchar, "Ox_Fe" varchar, "NUTS_0" varchar, "NUTS_1" varchar, "NUTS_2" varchar, "NUTS_3" varchar, "TH_LAT" varchar, "TH_LONG" varchar, "SURVEY_DATE" varchar, "Elev" varchar, "LC" varchar, "LU" varchar, "LC0_Desc" varchar, "LC1_Desc" varchar, "LU1_Desc" varchar);
WITH x AS (SELECT DISTINCT t."Depth" FROM t)
INSERT INTO data.depth(name)
SELECT meta.clean_value(x."Depth", 'varchar')::varchar FROM x
LEFT JOIN data.depth depth ON depth.name= x."Depth"
WHERE depth.id IS NULL;
WITH x AS (SELECT DISTINCT t."LC" FROM t)
INSERT INTO data.lc(name)
SELECT meta.clean_value(x."LC", 'varchar')::varchar FROM x
LEFT JOIN data.lc lc ON lc.name= x."LC"
WHERE lc.id IS NULL;
WITH x AS (SELECT DISTINCT t."LC1_Desc" FROM t)
INSERT INTO data.lc_detail(name)
SELECT meta.clean_value(x."LC1_Desc", 'varchar')::varchar FROM x
LEFT JOIN data.lc_detail lc_detail ON lc_detail.name= x."LC1_Desc"
WHERE lc_detail.id IS NULL;
WITH x AS (SELECT DISTINCT t."LC0_Desc" FROM t)
INSERT INTO data.lc_main(name)
SELECT meta.clean_value(x."LC0_Desc", 'varchar')::varchar FROM x
LEFT JOIN data.lc_main lc_main ON lc_main.name= x."LC0_Desc"
WHERE lc_main.id IS NULL;
WITH x AS (SELECT DISTINCT t."LU" FROM t)
INSERT INTO data.lu(name)
SELECT meta.clean_value(x."LU", 'varchar')::varchar FROM x
LEFT JOIN data.lu lu ON lu.name= x."LU"
WHERE lu.id IS NULL;
WITH x AS (SELECT DISTINCT t."LU1_Desc" FROM t)
INSERT INTO data.lu_detail(name)
SELECT meta.clean_value(x."LU1_Desc", 'varchar')::varchar FROM x
LEFT JOIN data.lu_detail lu_detail ON lu_detail.name= x."LU1_Desc"
WHERE lu_detail.id IS NULL;
WITH x AS (SELECT DISTINCT t."NUTS_0" FROM t)
INSERT INTO data.nuts_0(name)
SELECT meta.clean_value(x."NUTS_0", 'varchar')::varchar FROM x
LEFT JOIN data.nuts_0 nuts_0 ON nuts_0.name= x."NUTS_0"
WHERE nuts_0.id IS NULL;
WITH x AS (SELECT DISTINCT t."NUTS_1" FROM t)
INSERT INTO data.nuts_1(name)
SELECT meta.clean_value(x."NUTS_1", 'varchar')::varchar FROM x
LEFT JOIN data.nuts_1 nuts_1 ON nuts_1.name= x."NUTS_1"
WHERE nuts_1.id IS NULL;
WITH x AS (SELECT DISTINCT t."NUTS_2" FROM t)
INSERT INTO data.nuts_2(name)
SELECT meta.clean_value(x."NUTS_2", 'varchar')::varchar FROM x
LEFT JOIN data.nuts_2 nuts_2 ON nuts_2.name= x."NUTS_2"
WHERE nuts_2.id IS NULL;
WITH x AS (SELECT DISTINCT t."NUTS_3" FROM t)
INSERT INTO data.nuts_3(name)
SELECT meta.clean_value(x."NUTS_3", 'varchar')::varchar FROM x
LEFT JOIN data.nuts_3 nuts_3 ON nuts_3.name= x."NUTS_3"
WHERE nuts_3.id IS NULL;
WITH x AS (SELECT DISTINCT t."Depth", t."POINTID", t."NUTS_0", t."NUTS_1", t."NUTS_2", t."NUTS_3", t."TH_LAT", t."TH_LONG", t."Elev", t."LC", t."LU", t."LC0_Desc", t."LC1_Desc", t."LU1_Desc" FROM t)
INSERT INTO data.point(depth_id, point_key, nuts_0_id, nuts_1_id, nuts_2_id, nuts_3_id, lat, lon, elev, lc_id, lu_id, lc_main_id, lc_detail_id, lu_detail_id)
SELECT depth.id, meta.clean_value(x."POINTID", 'varchar')::varchar, nuts_0.id, nuts_1.id, nuts_2.id, nuts_3.id, meta.clean_value(x."TH_LAT", 'float')::float, meta.clean_value(x."TH_LONG", 'float')::float, meta.clean_value(x."Elev", 'int')::int, lc.id, lu.id, lc_main.id, lc_detail.id, lu_detail.id FROM x
LEFT JOIN data.point point ON point.point_key= x."POINTID"
LEFT JOIN data.depth depth ON depth.name = x."Depth"
LEFT JOIN data.nuts_0 nuts_0 ON nuts_0.name = x."NUTS_0"
LEFT JOIN data.nuts_1 nuts_1 ON nuts_1.name = x."NUTS_1"
LEFT JOIN data.nuts_2 nuts_2 ON nuts_2.name = x."NUTS_2"
LEFT JOIN data.nuts_3 nuts_3 ON nuts_3.name = x."NUTS_3"
LEFT JOIN data.lc lc ON lc.name = x."LC"
LEFT JOIN data.lu lu ON lu.name = x."LU"
LEFT JOIN data.lc_main lc_main ON lc_main.name = x."LC0_Desc"
LEFT JOIN data.lc_detail lc_detail ON lc_detail.name = x."LC1_Desc"
LEFT JOIN data.lu_detail lu_detail ON lu_detail.name = x."LU1_Desc"
WHERE point.id IS NULL;
INSERT INTO data.measurement(point_id, indicator_id, value, date)
SELECT x.id, i.id, meta.clean_value(t."pH_CaCl2", 'float')::float, meta.clean_value(t."SURVEY_DATE", 'date')::date FROM t
LEFT JOIN data.point x ON x.point_key = t."POINTID"
left join data.indicator i on i.name = 'pH (CaCl2)' left join data.measurement y on y.point_id = x.id and y.indicator_id = i.id and y.date = meta.clean_value(t."SURVEY_DATE", 'date')::date
WHERE y.id IS NULL AND meta.clean_value(t."pH_CaCl2", 'float')::float IS NOT NULL ;
INSERT INTO data.measurement(point_id, indicator_id, value, date)
SELECT x.id, i.id, meta.clean_value(t."pH_H2O", 'float')::float, meta.clean_value(t."SURVEY_DATE", 'date')::date FROM t
LEFT JOIN data.point x ON x.point_key = t."POINTID"
left join data.indicator i on i.name = 'pH (H2O)' left join data.measurement y on y.point_id = x.id and y.indicator_id = i.id and y.date = meta.clean_value(t."SURVEY_DATE", 'date')::date
WHERE y.id IS NULL AND meta.clean_value(t."pH_H2O", 'float')::float IS NOT NULL ;
INSERT INTO data.measurement(point_id, indicator_id, value, date)
SELECT x.id, i.id, meta.clean_value(t."EC", 'float')::float, meta.clean_value(t."SURVEY_DATE", 'date')::date FROM t
LEFT JOIN data.point x ON x.point_key = t."POINTID"
left join data.indicator i on i.name = 'EC' left join data.measurement y on y.point_id = x.id and y.indicator_id = i.id and y.date = meta.clean_value(t."SURVEY_DATE", 'date')::date
WHERE y.id IS NULL AND meta.clean_value(t."EC", 'float')::float IS NOT NULL ;
INSERT INTO data.measurement(point_id, indicator_id, value, date)
SELECT x.id, i.id, meta.clean_value(t."OC", 'float')::float, meta.clean_value(t."SURVEY_DATE", 'date')::date FROM t
LEFT JOIN data.point x ON x.point_key = t."POINTID"
left join data.indicator i on i.name = 'OC' left join data.measurement y on y.point_id = x.id and y.indicator_id = i.id and y.date = meta.clean_value(t."SURVEY_DATE", 'date')::date
WHERE y.id IS NULL AND meta.clean_value(t."OC", 'float')::float IS NOT NULL ;
INSERT INTO data.measurement(point_id, indicator_id, value, date)
SELECT x.id, i.id, meta.clean_value(t."CaCO3", 'float')::float, meta.clean_value(t."SURVEY_DATE", 'date')::date FROM t
LEFT JOIN data.point x ON x.point_key = t."POINTID"
left join data.indicator i on i.name = 'CaCO3' left join data.measurement y on y.point_id = x.id and y.indicator_id = i.id and y.date = meta.clean_value(t."SURVEY_DATE", 'date')::date
WHERE y.id IS NULL AND meta.clean_value(t."CaCO3", 'float')::float IS NOT NULL ;
INSERT INTO data.measurement(point_id, indicator_id, value, date)
SELECT x.id, i.id, meta.clean_value(t."P", 'float')::float, meta.clean_value(t."SURVEY_DATE", 'date')::date FROM t
LEFT JOIN data.point x ON x.point_key = t."POINTID"
left join data.indicator i on i.name = 'P' left join data.measurement y on y.point_id = x.id and y.indicator_id = i.id and y.date = meta.clean_value(t."SURVEY_DATE", 'date')::date
WHERE y.id IS NULL AND meta.clean_value(t."P", 'float')::float IS NOT NULL ;
INSERT INTO data.measurement(point_id, indicator_id, value, date)
SELECT x.id, i.id, meta.clean_value(t."N", 'float')::float, meta.clean_value(t."SURVEY_DATE", 'date')::date FROM t
LEFT JOIN data.point x ON x.point_key = t."POINTID"
left join data.indicator i on i.name = 'N' left join data.measurement y on y.point_id = x.id and y.indicator_id = i.id and y.date = meta.clean_value(t."SURVEY_DATE", 'date')::date
WHERE y.id IS NULL AND meta.clean_value(t."N", 'float')::float IS NOT NULL ;
INSERT INTO data.measurement(point_id, indicator_id, value, date)
SELECT x.id, i.id, meta.clean_value(t."K", 'float')::float, meta.clean_value(t."SURVEY_DATE", 'date')::date FROM t
LEFT JOIN data.point x ON x.point_key = t."POINTID"
left join data.indicator i on i.name = 'K' left join data.measurement y on y.point_id = x.id and y.indicator_id = i.id and y.date = meta.clean_value(t."SURVEY_DATE", 'date')::date
WHERE y.id IS NULL AND meta.clean_value(t."K", 'float')::float IS NOT NULL ;
INSERT INTO data.measurement(point_id, indicator_id, value, date)
SELECT x.id, i.id, meta.clean_value(t."OC (20-30 cm)", 'float')::float, meta.clean_value(t."SURVEY_DATE", 'date')::date FROM t
LEFT JOIN data.point x ON x.point_key = t."POINTID"
left join data.indicator i on i.name = 'OC (20-30 cm)' left join data.measurement y on y.point_id = x.id and y.indicator_id = i.id and y.date = meta.clean_value(t."SURVEY_DATE", 'date')::date
WHERE y.id IS NULL AND meta.clean_value(t."OC (20-30 cm)", 'float')::float IS NOT NULL ;
INSERT INTO data.measurement(point_id, indicator_id, value, date)
SELECT x.id, i.id, meta.clean_value(t."CaCO3 (20-30 cm)", 'float')::float, meta.clean_value(t."SURVEY_DATE", 'date')::date FROM t
LEFT JOIN data.point x ON x.point_key = t."POINTID"
left join data.indicator i on i.name = 'CaCO3 (20-30 cm)' left join data.measurement y on y.point_id = x.id and y.indicator_id = i.id and y.date = meta.clean_value(t."SURVEY_DATE", 'date')::date
WHERE y.id IS NULL AND meta.clean_value(t."CaCO3 (20-30 cm)", 'float')::float IS NOT NULL ;
INSERT INTO data.measurement(point_id, indicator_id, value, date)
SELECT x.id, i.id, meta.clean_value(t."Ox_Al", 'float')::float, meta.clean_value(t."SURVEY_DATE", 'date')::date FROM t
LEFT JOIN data.point x ON x.point_key = t."POINTID"
left join data.indicator i on i.name = 'Ox_Al' left join data.measurement y on y.point_id = x.id and y.indicator_id = i.id and y.date = meta.clean_value(t."SURVEY_DATE", 'date')::date
WHERE y.id IS NULL AND meta.clean_value(t."Ox_Al", 'float')::float IS NOT NULL ;
INSERT INTO data.measurement(point_id, indicator_id, value, date)
SELECT x.id, i.id, meta.clean_value(t."Ox_Fe", 'float')::float, meta.clean_value(t."SURVEY_DATE", 'date')::date FROM t
LEFT JOIN data.point x ON x.point_key = t."POINTID"
left join data.indicator i on i.name = 'Ox_Fe' left join data.measurement y on y.point_id = x.id and y.indicator_id = i.id and y.date = meta.clean_value(t."SURVEY_DATE", 'date')::date
WHERE y.id IS NULL AND meta.clean_value(t."Ox_Fe", 'float')::float IS NOT NULL ;
END $function$
*/
}
/**
* @function delete_custom_geometry
* @memberof data
* @description Delete custom geometry
* @param {integer} PersonId
* @param {integer} Id
* @returns {void}
*/
function delete_custom_geometry() {
/*
CREATE OR REPLACE FUNCTION data.delete_custom_geometry("PersonId" integer, "Id" integer)
RETURNS void
LANGUAGE plpgsql
AS $function$
BEGIN
DELETE FROM data.custom_geometry WHERE id = "Id" AND person_id = "PersonId";
END $function$
*/
}
/**
* @function delete_file
* @memberof data
* @description Delete file
* @param {integer} PersonId
* @param {integer} FileId
* @returns {void}
*/
function delete_image() {
/*
CREATE OR REPLACE FUNCTION data.delete_image("Id" integer)
RETURNS void
LANGUAGE plpgsql
AS $function$
BEGIN
IF EXISTS (
SELECT 1 FROM data.image i
INNER JOIN data.simple_observation so ON so.id = i.simple_observation_id
INNER JOIN data.custom_geometry g ON g.id = so.custom_geometry_id
INNER JOIN auth.vw_partner vp ON vp.user_id = g.person_id AND vp.partner_user_id = auth.get_context_person_id()
) THEN
DELETE FROM data.image WHERE id = "Id";
RETURN;
END IF;
PERFORM meta.raise_error(4, '') ;
END$function$
*/
}
/**
* @function delete_image_from_os
* @memberof data
* @description Delete image from os
* @returns {trigger}
*/
function delete_image_from_os() {
/*
CREATE OR REPLACE FUNCTION data.delete_image_from_os()
RETURNS trigger
LANGUAGE plpgsql
AS $function$
begin
INSERT INTO general.file_delete VALUES (old.id || old.extension);
RETURN OLD;
end;
$function$
*/
}
/**
* @function delete_simple_observation
* @memberof data
* @description Delete simple observation
* @param {integer} Id
* @returns {void}
*/
function delete_simple_observation() {
/*
CREATE OR REPLACE FUNCTION data.delete_simple_observation("Id" integer)
RETURNS void
LANGUAGE plpgsql
AS $function$
BEGIN
DELETE FROM data.simple_observation WHERE id = "Id";
END $function$
*/
}
/**
* @function extract_file_name
* @memberof data
* @description Extract file name from a path
* @param {character_varying} s
* @returns {character_varying}
*/
function extract_file_name() {
/*
CREATE OR REPLACE FUNCTION data.extract_file_name(s character varying)
RETURNS character varying
LANGUAGE plpgsql
AS $function$BEGIN
-- Routine body goes here...
RETURN REPLACE(REPLACE (substring(
s,
length(s) - position('/' in reverse(s)) + 2
), '.tif', ''), '.png', '');
END$function$
*/
}
/**
* @function generate_observations_for_points
* @memberof data
* @description Generate observations for points
* @param {integer} SiteId
* @returns {void}
*/
function generate_observations_for_points() {
/*
CREATE OR REPLACE FUNCTION data.generate_observations_for_points("SiteId" integer)
RETURNS void
LANGUAGE plpgsql
AS $function$
BEGIN
INSERT INTO data.sample (point_id)
SELECT id FROM data.point WHERE site_id = "SiteId" and lat IS NULL;
INSERT INTO data.observation (sample_id, topsoil)
SELECT s.id, true
FROM data.sample s
INNER JOIN data.point p ON p.id = s.point_id
WHERE site_id = "SiteId";
END $function$
*/
}
/**
* @function get_all_assets
* @memberof data
* @description Get all assets
* @returns {Object}
* @property {character_varying} id
* @property {boolean} ignore
* @property {integer} asset_catalog_id
* @property {character_varying} title
* @property {character_varying} description
* @property {integer} asset_theme_id
* @property {character_varying} keywords_list
* @property {integer} asset_version_id
* @property {character_varying} doi
* @property {integer} unit_id
* @property {character_varying} scale_factor
* @property {integer} person_id
* @property {character_varying} providers_list
* @property {integer} license_id
* @property {character_varying} constellation_list
* @property {character_varying} platform
* @property {character_varying} instruments_list
* @property {character_varying} gsd
* @property {date} start_date
* @property {date} end_date
* @property {integer} date_step
* @property {character_varying} date_offset
* @property {integer} date_unit_id
* @property {integer} date_style_id
* @property {boolean} ignore_29feb
* @property {character_varying} depth_list
* @property {character_varying} main_sld_url
* @property {character_varying} sld_1_url
* @property {character_varying} main_qml_url
* @property {character_varying} main_url
* @property {character_varying} asset_catalog_id_val
* @property {character_varying} asset_theme_id_val
* @property {character_varying} asset_version_id_val
* @property {character_varying} unit_id_val
* @property {character_varying} person_id_val
* @property {character_varying} license_id_val
* @property {character_varying} date_unit_id_val
* @property {character_varying} date_style_id_val
*/
function get_all_assets() {
/*
CREATE OR REPLACE FUNCTION data.get_all_assets()
RETURNS TABLE(id character varying, ignore boolean, asset_catalog_id integer, title character varying, description character varying, asset_theme_id integer, keywords_list character varying, asset_version_id integer, doi character varying, catalog_unit__unit_id integer, scale_factor character varying, auth_person__person_id integer, providers_list character varying, license_id integer, constellation_list character varying, platform character varying, instruments_list character varying, gsd character varying, start_date date, end_date date, date_step integer, date_offset character varying, date_catalog_unit__unit_id integer, date_style_id integer, ignore_29feb boolean, depth_list character varying, main_sld_url character varying, sld_1_url character varying, main_qml_url character varying, main_url character varying, asset_catalog_id_val character varying, asset_theme_id_val character varying, asset_version_id_val character varying, catalog_unit__unit_id_val character varying, auth_person__person_id_val character varying, license_id_val character varying, date_catalog_unit__unit_id_val character varying, date_style_id_val character varying)
LANGUAGE plpgsql
AS $function$
BEGIN
RETURN QUERY
SELECT
t.orig_id, t.ignore, t.asset_catalog_id, t.title, t.description, t.asset_theme_id, t.keywords_list, t.asset_version_id, t.doi, t.unit_id, t.scale_factor, t.person_id, t.providers_list, t.license_id, t.constellation_list, t.platform, t.instruments_list, t.gsd, t.start_date, t.end_date, t.date_step, t.date_offset, t.date_unit_id, t.date_style_id, t.ignore_29feb, t.depth_list, t.main_sld_url, t.sld_1_url, t.main_qml_url, t.main_url
, asset_catalog_id_t.name::VARCHAR AS asset_catalog_id_val, asset_theme_id_t.name::VARCHAR AS asset_theme_id_val, asset_version_id_t.name::VARCHAR AS asset_version_id_val, unit_id_t.name::VARCHAR AS unit_id_val, person_id_t.name::VARCHAR AS person_id_val, license_id_t.name::VARCHAR AS license_id_val, date_unit_id_t.name::VARCHAR AS date_unit_id_val, date_style_id_t.name::VARCHAR AS date_style_id_val
FROM data.asset t
LEFT JOIN data.asset_catalog asset_catalog_id_t ON asset_catalog_id_t.id = t.asset_catalog_id
LEFT JOIN data.asset_theme asset_theme_id_t ON asset_theme_id_t.id = t.asset_theme_id
LEFT JOIN catalog.asset_version asset_version_id_t ON asset_version_id_t.id = t.asset_version_id
LEFT JOIN catalog.unit unit_id_t ON unit_id_t.id = t.unit_id
LEFT JOIN auth.person person_id_t ON person_id_t.id = t.person_id
LEFT JOIN data.license license_id_t ON license_id_t.id = t.license_id
LEFT JOIN data.date_unit date_unit_id_t ON date_unit_id_t.id = t.date_unit_id
LEFT JOIN data.date_style date_style_id_t ON date_style_id_t.id = t.date_style_id
;
END $function$
*/
}
/**
* @function get_assets
* @memberof data
* @description Get assets
* @param {integer} TitleId
* @param {character_varying} Depth
* @param {integer} Srid
* @returns {json}
*/
function get_assets() {
/*
CREATE OR REPLACE FUNCTION data.get_assets("TitleId" integer, "Depth" character varying, "Srid" integer)
RETURNS json
LANGUAGE plpgsql
AS $function$
BEGIN
-- Routine body goes here...
RETURN (
SELECT json_agg(t.*)
FROM (
--SELECT row_number() OVER (ORDER BY time_span DESC) value,
--time_span label,
--'image/tiff' type,
--url source
--FROM data.vw_asset
--WHERE title_id = "TitleId" and (depth = "Depth" or "Depth" is null)
--ORDER BY 2 DESC
SELECT row_number() OVER (ORDER BY temporal_coverage_start || '-' || temporal_coverage_end DESC) value,
temporal_coverage_start || '-' || temporal_coverage_end || ': ' || value label,
'image/tiff' type,
wasabi_link source,
s.indicator_id,
"Depth" depth
FROM data.shdc_file f
LEFT JOIN data.shdc s ON s.id = f.shdc_id
LEFT JOIN data.depth d ON d.id = f.depth_id
WHERE shdc_id = "TitleId" and (d.name = "Depth" or "Depth" is null)
ORDER BY temporal_coverage_start DESC, value
) t
);
END
$function$
*/
}
/**
* @function get_assets_for_statistics
* @memberof data
* @description Get assets for statistics
* @param {integer} IndicatorId
* @returns {Object} integer indicator_idcharacter_varying urlcharacter_varying scale_factorinteger no_datatext time_spaninteger depth_id
*/
function get_assets_for_statistics() {
/*
CREATE OR REPLACE FUNCTION data.get_assets_for_statistics("IndicatorId" integer)
RETURNS TABLE(indicator_id integer, url character varying, scale_factor character varying, no_data integer, time_span text, depth_id integer)
LANGUAGE plpgsql
AS $function$
BEGIN
RETURN QUERY
WITH a AS (
SELECT a.indicator_id, f.wasabi_link url, (a.scale_factor)::varchar, COALESCE(a.no_data,0) no_data, f.temporal_coverage_start || '/' || f.temporal_coverage_end time_span, f.depth_id, f.value,
ROW_NUMBER() OVER (PARTITION BY a.indicator_id ORDER BY f.temporal_coverage_start DESC) AS row_num
FROM data.shdc a
INNER JOIN data.shdc_file f ON a.id = f.shdc_id
INNER JOIN data.indicator i ON a.indicator_id = i.id
WHERE ((f.depth_id = 6 AND f.value = 'm') OR f.value = 'c' )
AND (a.indicator_id = "IndicatorId" OR "IndicatorId" IS NULL)
)
select a.indicator_id, a.url, a.scale_factor, COALESCE(a.no_data,0) no_data, a.time_span, a.depth_id
FROM a
WHERE a.row_num = 1;
END $function$
*/
}
/**
* @function get_catalogs
* @memberof data
* @description Get catalogs
* @param {integer} LangId
* @returns {json}
*/
function get_catalogs() {
/*
CREATE OR REPLACE FUNCTION data.get_catalogs("LangId" integer)
RETURNS json
LANGUAGE plpgsql
AS $function$
BEGIN
RETURN (
SELECT json_build_object(
'aiModels', (SELECT json_agg(t.*) FROM (SELECT id value, name label FROM general.ai_model WHERE active ORDER BY 2) t),
'srids' , (SELECT '[3857, 3035]'::json),
'dataSources', (SELECT json_agg(t.*) FROM (SELECT id value, name label FROM data.data_source ORDER BY 2) t),
'descriptionsSav', (
SELECT json_agg(t.*)
FROM (SELECT a.indicator_id, a.id value, a.name label, COALESCE (c.code, '#FF0000') color_code
FROM data.attribute_description a
LEFT JOIN general.color c ON c.id = a.color_id
ORDER by 1, 3)
t),
'descriptions', (SELECT json_object_agg(t.id, t.attributes) descriptions
FROM (
SELECT i.id,
( SELECT json_object_agg(t.value, json_build_object('name', t.name, 'color_code', COALESCE (c.code, '#FF0000') ))
FROM data.attribute_description t
LEFT JOIN general.color c ON c.id = t.color_id
WHERE t.indicator_id = i.id
) attributes
FROM data.indicator i WHERE NOT i.numerical
) t),
'properties', (SELECT json_agg(t.*)
FROM (SELECT p.id, p.name, p.indicator_id, u.name unit, p.data_type_id, i.numerical
FROM data.property p
LEFT JOIN data.indicator i on i.id = p.indicator_id
LEFT JOIN catalog.unit u ON u.id = p.unit_id)
t),
'forum_topics', (SELECT json_agg(t.*) FROM (SELECT id value, name label FROM general.forum_topic ORDER BY 2) t),
'rooms', (SELECT json_agg(t.*) FROM (SELECT id value, name label FROM general.room ORDER BY 2) t))
);
END $function$
*/
}
/**
* @function get_custom_geometry
* @memberof data
* @description Get custom geometry
* @param {integer} PersonId
* @param {integer} Id
* @returns {json}
*/
function get_custom_geometry() {
/*
CREATE OR REPLACE FUNCTION data.get_custom_geometry("Id" integer)
RETURNS json
LANGUAGE plpgsql
AS $function$
DECLARE
feature_collection json;
BEGIN
SELECT jsonb_build_object(
'type', 'FeatureCollection',
'features', json_agg(t.feature)
) AS fc
INTO feature_collection
FROM (
-- real geometries
SELECT json_build_object(
'type', 'Feature',
'id', 'cg' || id::VARCHAR,
'geometry', g.geometry,
'properties', json_build_object (
'key', id,
'name', name,
'public', public,
'editor', 'simple-observation'
)
) feature
FROM data.custom_geometry g
INNER JOIN auth.vw_partner vp ON vp.user_id = g.person_id AND vp.partner_user_id = auth.get_context_person_id()
AND (g.id = "Id" OR "Id" IS NULL )
WHERE g.geometry IS NOT NULL
UNION ALL
-- files
SELECT json_build_object(
'type', 'Feature',
'id', 'im' || i.id::VARCHAR,
'geometry', st_setsrid(st_makepoint(i.lon, i.lat), 4326),
'properties', json_build_object (
'key', g.id,
'extension', i.extension,
'image_id', i.id,
'compass', i.compass,
'name', i.name
)
) feature
FROM data.custom_geometry g
INNER JOIN auth.vw_partner vp ON vp.user_id = g.person_id AND vp.partner_user_id = auth.get_context_person_id()
INNER JOIN data.simple_observation so ON so.custom_geometry_id = g.id
INNER JOIN data.image i ON i.simple_observation_id = so.id
WHERE (g.id = "Id" OR "Id" IS NULL)
) t;
RETURN feature_collection;
END
$function$
*/
}
/**
* @function get_data_source_atts
* @memberof data
* @description Get data source data
* @param {integer} PersonId
* @param {integer} LangId
* @returns {json}
*/
function get_data_source_atts() {
/*
CREATE OR REPLACE FUNCTION data.get_data_source_atts("DataSourceId" integer)
RETURNS TABLE(id integer, name character varying, data_type character varying, decimals integer)
LANGUAGE plpgsql
AS $function$
BEGIN
RETURN QUERY (
SELECT DISTINCT i.id, i.name, dt.name, i.decimals_for_display
FROM data.measurement m
INNER JOIN data.indicator i ON i.id = m.indicator_id
LEFT JOIN meta.data_type dt ON dt.id = i.data_type_id
WHERE m.data_source_id = "DataSourceId"
UNION
SELECT DISTINCT i.id, i.name, 'character varying', 0
FROM data.attribute a
INNER JOIN data.attribute_description ad ON ad.id = a.attribute_description_id
INNER JOIN data.indicator i ON i.id = ad.indicator_id
WHERE a.data_source_id = "DataSourceId"
ORDER BY 2
);
END $function$
*/
}
/**
* @function get_data_source_data
* @memberof data
* @description Get data source data
* @param {text} Params
* @param {integer} PersonId
* @param {integer} LangId
* @returns {json}
*/
function get_data_source_data() {
/*
CREATE OR REPLACE FUNCTION data.get_data_source_data("Params" text, "PersonId" integer, "LangId" integer)
RETURNS json
LANGUAGE plpgsql
AS $function$
DECLARE v_data_source_id INT;
v_sql VARCHAR;
v_part VARCHAR;
v_a1 VARCHAR;
v_a2 VARCHAR;
r TEXT;
BEGIN
v_data_source_id := ("Params"::json)->'data_source_id';
-- check if data source is public or user has access to it
IF NOT EXISTS (
SELECT 1 FROM data.data_source ds
LEFT JOIN auth.data_source_person dsp ON ds.id = dsp.data_source_id AND dsp.person_id = auth.get_context_person_id()
WHERE ds.public OR dsp.id IS NOT NULL) THEN
RAISE EXCEPTION 'Not allowed';
END IF;
DROP TABLE IF EXISTS ind;
CREATE TEMP TABLE ind AS
SELECT DISTINCT i.id, i.name
FROM data.measurement m
INNER JOIN data.indicator i ON i.id = m.indicator_id
WHERE m.data_source_id = v_data_source_id
UNION
SELECT DISTINCT i.id, i.name
FROM data.attribute a
INNER JOIN data.attribute_description ad ON ad.id = a.attribute_description_id
INNER JOIN data.indicator i ON i.id = ad.indicator_id
WHERE a.data_source_id = v_data_source_id
ORDER BY 2;
v_sql := E'SELECT json_agg(t.*) FROM (\n SELECT ROW_NUMBER() OVER (ORDER BY 1) id, COALESCE(p.sample::varchar, p.name, p.point_key) name, ids[2]::int elev, d.name depth, ids[4]::date date, ';
SELECT string_agg('t."' || ind.name || '"', ', ') INTO v_part
FROM ind ORDER BY 1;
v_part := v_part || ', s.id IS NOT NULL has_spectra, s.wavelengths, s.values';
v_a1 := 'SELECT ARRAY[p.id::varchar, p.elev::varchar, m.depth_id::varchar, m.date::varchar], i.name, m.value::varchar ' ||
'FROM data.measurement m ' ||
'INNER JOIN data.indicator i on i.id = m.indicator_id ' ||
'INNER JOIN data.point p on p.id = m.point_id WHERE m.data_source_id = ' || v_data_source_id ||
' UNION ' ||
'SELECT ARRAY[p.id::varchar, p.elev::varchar, a.depth_id::varchar, a.date::varchar], i.name, ad.name ' ||
'FROM data.attribute a ' ||
'INNER JOIN data.attribute_description ad on ad.id = a.attribute_description_id ' ||
'INNER JOIN data.indicator i on i.id = ad.indicator_id ' ||
'INNER JOIN data.point p on p.id = a.point_id WHERE a.data_source_id = ' || v_data_source_id ||
' ORDER BY 1';
-- v_a2 := 'SELECT DISTINCT i.name FROM data.indicator i inner join data.measurement m on m.indicator_id = i.id AND m.data_source_id = ' || v_data_source_id;
v_a2 := 'SELECT name FROM ind ORDER BY 1';
v_sql := v_sql || v_part || E' FROM ( SELECT * FROM crosstab (\n''' ||
v_a1 || E''' , \n''' || v_a2 ||
''') AS ct (ids varchar[], ';
SELECT string_agg('"' || name || '" varchar', ', ') INTO v_part
FROM ind;
v_sql := v_sql || v_part || ')) t ' ||
'INNER JOIN data.point p ON p.id = ids[1]::int ' ||
'LEFT JOIN data.depth d ON d.id = ids[3]::int ' ||
'LEFT JOIN data.spectrum s ON s.point_id = p.id AND s.date = ids[4]::date AND s.data_source_id = ' || v_data_source_id::varchar ||
' ORDER BY 1, 2, 3, 4 ) t;';
IF v_sql IS NULL THEN
RETURN NULL;
END IF;
RAISE NOTICE 'SQL: %', v_sql;
EXECUTE v_sql INTO r;
RETURN r;
END
$function$
*/
}
/**
* @function get_data_source_vals
* @memberof data
* @description Get data source values
* @param {integer} DataSourceId
* @returns {Object}
* @property {character_varying} point_name
* @property {date} date
*/
function get_data_source_spectra() {
/*
CREATE OR REPLACE FUNCTION data.get_data_source_spectra("DataSourceId" integer)
RETURNS TABLE(name character varying, date date)
LANGUAGE plpgsql
AS $function$
BEGIN
RETURN QUERY (
SELECT COALESCE(p.sample::VARCHAR, p.name, p.point_key), s.date
FROM data.spectrum s
INNER JOIN data.point p ON p.id = s.point_id
WHERE s.data_source_id = "DataSourceId"
ORDER BY 1, 2
);
END
$function$
*/
}
/**
* @function get_data_source_vals_overload
* @overload get_data_source_vals
* @memberof data
* @description Get data source values
* @param {integer} DataSourceId
* @returns {json}
*/
function get_data_source_vals_overload() {
/*
CREATE OR REPLACE FUNCTION data.get_data_source_vals("DataSourceId" integer)
RETURNS TABLE(id integer, point character varying, depth character varying, date date, has_spectra boolean, indicator_id integer, value character varying)
LANGUAGE plpgsql
AS $function$
BEGIN
RETURN QUERY (
SELECT p.id,
COALESCE(p.sample::VARCHAR, p.name, p.point_key) point,
d.name depth,
m.date,
s.id IS NOT NULL,
m.indicator_id,
m.value::VARCHAR
FROM data.measurement m
INNER JOIN data.point p ON p.id = m.point_id
LEFT JOIN data.depth d ON d.id = m.depth_id
LEFT JOIN data.spectrum s ON s.point_id = p.id AND s.date = m.date AND s.data_source_id = "DataSourceId"
WHERE m.data_source_id = "DataSourceId"
UNION
SELECT p.id,
COALESCE(p.sample::VARCHAR, p.name, p.point_key) point,
d.name depth,
a.date,
s.id IS NOT NULL,
a.indicator_id,
ad.name
FROM data.attribute a
INNER JOIN data.attribute_description ad ON ad.id = a.attribute_description_id
INNER JOIN data.point p ON p.id = a.point_id
LEFT JOIN data.depth d ON d.id = a.depth_id
LEFT JOIN data.spectrum s ON s.point_id = p.id AND s.date = a.date AND s.data_source_id = "DataSourceId"
WHERE a.data_source_id = "DataSourceId"
ORDER BY 2, 3, 4
);
END
$function$
*/
}
/**
* @function get_nuts
* @memberof data
* @description Get NUTS regions by level, zoom and bounding box
* @param {integer} Level
* @param {integer} Srid
* @param {integer} Zoom
* @param {varchar} Extent
* @param {integer} IndicatorId
* @param {integer} DataSourceId
* @returns {json}
*/
function get_field_boundaries() {
/*
CREATE OR REPLACE FUNCTION data.get_field_boundaries("Srid" integer, "Zoom" integer, "Extent" character varying)
RETURNS json
LANGUAGE plpgsql
AS $function$
DECLARE bb geometry;
simplify float;
-- SELECT * FROM data.get_nuts(0, 3035, 10, 2217542.415101382,1337159.7278276538,6191714.062701465,4547067.5970431045, 1)
BEGIN
bb := general.envelope ("Extent", "Srid");
bb := st_transform(bb, 4326);
simplify := general.simplify("Zoom") * 0.000005;
RAISE NOTICE 'bb: %', bb;
RETURN (
SELECT json_build_object (
'type', 'FeatureCollection',
'features', json_agg(st_asgeojson(t.*)::json)
)
FROM (
SELECT b.id || ' ' || COALESCE(a.name, '') name, b.ogc_fid key, 5 geometry_type_id, b.area, b.determination_datetime, b."planet:ca_ratio", b."planet:micd", b."planet:qa", b.determination_method,
COALESCE(c.code, '#FF0000') color_code, COALESCE(c.code, '#FF0000') || '3f' fill_color_code, a.name crop_type,
st_transform(st_simplify(b.geometry, simplify, false), "Srid") geometry
FROM data.field_boundary b
LEFT JOIN data.attribute_description a ON a.indicator_id = 49 and a.value = b.crop_type_id
LEFT JOIN general.color c ON a.color_id = c.id
WHERE st_intersects(b.geometry, bb)
) t
);
END
$function$
*/
}
/**
* @function get_geometry
* @memberof data
* @description Get geometry based on id, srid and geometry type id
* @param {integer} Id
* @param {integer} Srid
* @returns {json}
*/
function get_geometries() {
/*
CREATE OR REPLACE FUNCTION data.get_geometries("Ids" integer[], "Srid" integer, "Zoom" integer, "Extent" character varying, "GeometryTypeIds" integer[])
RETURNS json
LANGUAGE plpgsql
AS $function$
DECLARE bb geometry;
DECLARE simplify float;
BEGIN
-- Get the bounding box of the geometries
bb := general.envelope( "Extent", "Srid");
bb := st_transform(bb, 3035);
simplify := general.simplify( "Zoom");
RETURN (
SELECT jsonb_build_object (
'type', 'FeatureCollection',
'features', json_agg(
json_build_object(
'type', 'Feature',
'geometry', st_asgeojson(t.geom)::json,
'properties', t.properties
)
)
) FROM (
WITH a1 AS (
SELECT unnest("Ids") AS parent_id, generate_series(1, array_length("Ids",1)) AS idx
),
a2 AS (
SELECT unnest("GeometryTypeIds") AS geometry_type_id, generate_series(1, array_length("GeometryTypeIds",1)) AS idx
)
SELECT b.id, b.properties::json, st_transform(st_simplify(b.geom, simplify, false), "Srid") geom, level1, level2
FROM a1
INNER JOIN a2 ON a1.idx = a2.idx
INNER JOIN data.vw_geometry b ON b.geometry_type_id = a2.geometry_type_id AND b.parent_id = a1.parent_id
WHERE a2.geometry_type_id <> 5 AND st_intersects(b.geom, bb)
UNION ALL
SELECT b.ogc_fid, json_build_object('geometry_type_id', 5, 'key', b.ogc_fid, 'name', b.id, 'color_code', COALESCE(c.code, '#0000FF'), 'fill_color_code', COALESCE(c.code, '#0000FF') || '3f', 'crop_type' , d.name),
st_transform(st_simplify(b.geometry, simplify, false), "Srid") geom, 4, 0
FROM a1
INNER JOIN a2 ON a1.idx = a2.idx
INNER JOIN data.field_boundary b ON b.ogc_fid = a1.parent_id
LEFT JOIN data.attribute_description d ON d.indicator_id = 49 and d.value = b.crop_type_id
LEFT JOIN general.color c ON c.id = d.color_id
WHERE a2.geometry_type_id = 5 AND st_intersects(b.geometry, bb)
ORDER BY level1, level2
) t
);
END$function$
*/
}
/**
* @function get_geometries_for_statistics
* @memberof data
* @description Get geometries for statistics
* @param {integer} IndicatorId
* @returns {Object} integer parent_idinteger geometry_type_idtext geometrycharacter_varying name
*/
function get_geometries_for_statistics() {
/*
CREATE OR REPLACE FUNCTION data.get_geometries_for_statistics("IndicatorId" integer)
RETURNS TABLE(parent_id integer, geometry_type_id integer, geometry text, name character varying)
LANGUAGE plpgsql
AS $function$
BEGIN
RETURN QUERY
select DISTINCT g.parent_id, g.geometry_type_id, st_asgeojson(st_union(st_makevalid(g.geom))) geometry, g.name
FROM data.vw_geometry g
LEFT JOIN data.geometry_statistics s
ON s.parent_id = g.parent_id
AND s.geometry_type_id = g.geometry_type_id AND (s.indicator_id = "IndicatorId" OR "IndicatorId" IS NULL)
WHERE s.id IS NULL AND g.geometry_type_id !=3--AND g.name = 'España'
GROUP BY g.parent_id, g.geometry_type_id, g.name
--LIMIT 10
;
END $function$
*/
}
/**
* @function get_geometry_overload
* @overload get_geometry
* @memberof data
* @description Get geometry based on id, srid and geometry type id
* @param {integer} Id
* @param {integer} Srid
* @returns {json}
*/
function get_geometry_overload() {
/*
CREATE OR REPLACE FUNCTION data.get_geometry("Id" integer, "Srid" integer, "Zoom" integer, "Extent" character varying, "GeometryTypeId" integer)
RETURNS json
LANGUAGE plpgsql
AS $function$
DECLARE bb geometry;
DECLARE simplify float;
BEGIN
bb := general.envelope( "Extent", "Srid");
bb := st_transform(bb, 3035);
simplify := general.simplify( "Zoom");
IF "GeometryTypeId" = 5 THEN
RETURN (
SELECT json_build_object (
'type', 'FeatureCollection',
'features', json_agg(st_asgeojson(t.*)::json)
) FROM (
SELECT b.id, b.ogc_fid, b.determination_method, b."planet:qa", b."planet:micd", b."planet:ca_ratio", b.determination_datetime, b.area, st_transform(st_simplify(geometry, simplify), "Srid") geom
FROM data.field_boundary b
WHERE b.ogc_fid = "Id"
) t
);
ELSE
RETURN (
SELECT jsonb_build_object (
'type', 'FeatureCollection',
'features', json_agg(
json_build_object(
'type', 'Feature',
'geometry', st_asgeojson(t.geom)::json,
'properties', t.properties
)
)
) FROM (
SELECT b.id, b.properties::jsonb, st_transform(st_simplify(geom, simplify), "Srid") geom
--SELECT null properties, st_union(st_transform(st_makevalid(geom), "Srid")) geom
FROM data.vw_geometry b
WHERE b.parent_id = "Id" AND geometry_type_id = "GeometryTypeId"
) t
);
END IF;
END$function$
*/
}
/**
* @function get_shape_geometry
* @memberof data
* @description Get shape geometry
* @param {integer} Id
* @param {integer} Srid
* @returns {json}
*/
function get_geometry_shape() {
/*
CREATE OR REPLACE FUNCTION data.get_geometry_shape("Id" integer, "Srid" integer)
RETURNS json
LANGUAGE plpgsql
AS $function$
BEGIN
RETURN (
SELECT jsonb_build_object (
'type', 'FeatureCollection',
'features', json_agg(
json_build_object(
'type', 'Feature',
'geometry', st_asgeojson(t.geom)::json,
'properties', t.properties
)
)
)
FROM (
SELECT b.id, b.properties, st_transform(geom, "Srid") geom
FROM data.shape_geometry b
WHERE b.shape_id = "Id"
) t
);
END$function$
*/
}
/**
* @function get_geometry_statistics
* @memberof data
* @description Get geometry statistics
* @param {text} Params
* @param {integer} PersonId
* @param {integer} LangId
* @returns {json}
*/
function get_geometry_statistics() {
/*
CREATE OR REPLACE FUNCTION data.get_geometry_statistics("Params" text, "PersonId" integer, "LangId" integer)
RETURNS json
LANGUAGE plpgsql
AS $function$
DECLARE
v_indicator_id INTEGER;
v_numerical bool;
BEGIN
v_indicator_id := "Params"::json->>'indicator_id';
SELECT numerical INTO v_numerical FROM data.indicator WHERE id = v_indicator_id;
IF v_numerical THEN
RETURN (SELECT json_agg(t) FROM (
select g.id, g.type, g.country, g.name, g.atts, d.name data_source, i.description indicator, g.name || '-' || d.name label, s.*
from data.geometry_statistics s
INNER JOIN data.vw_geom g ON g.parent_id = s.parent_id AND g.geometry_type_id = s.geometry_type_id
INNER JOIN data.indicator i ON i.id = s.indicator_id
INNER JOIN data.data_source d ON d.id = s.data_source_id
WHERE s.indicator_id = v_indicator_id
ORDER BY 2, 3, 4, 6
) t);
ELSE
RETURN (SELECT json_agg(t) FROM (
SELECT g.id, g.type, g.country, g.name, g.atts, d.name data_source, i.description indicator, g.name || '-' || d.name label,
s.*, s2.x, s2.y FROM
( SELECT
s.parent_id,
s.geometry_type_id,
s.data_source_id,
s.depth_id,
STRING_AGG(
(a.name || ' (' ||
CASE WHEN s.n > 0 THEN s.freq * 100. / s.n ELSE 0 END :: int
|| '%)'),
', ' ORDER BY s.freq DESC
) top_values
FROM (
SELECT ROW_NUMBER() OVER (PARTITION BY s.parent_id, s.geometry_type_id, s.data_source_id ORDER BY t.freq DESC) rn,
s.parent_id, s.geometry_type_id, s.data_source_id, s.depth_id, s.n, t.val, t.freq
FROM data.geometry_statistics s,
LATERAL unnest(x, y) AS t(val, freq)
WHERE s.indicator_id = v_indicator_id
) s
INNER JOIN data.attribute_description a
ON a.indicator_id = v_indicator_id AND a.value = s.val
WHERE s.rn <= 3
GROUP BY s.parent_id, s.geometry_type_id, s.data_source_id, s.depth_id
) s
INNER JOIN data.geometry_statistics s2
ON s2.parent_id = s.parent_id
AND s2.geometry_type_id = s.geometry_type_id
AND s2.data_source_id = s.data_source_id
AND s2.indicator_id = v_indicator_id
AND s2.depth_id = s.depth_id
INNER JOIN data.vw_geom g
ON g.parent_id = s.parent_id AND g.geometry_type_id = s.geometry_type_id
INNER JOIN data.indicator i
ON i.id = v_indicator_id
INNER JOIN data.data_source d
ON d.id = s.data_source_id
ORDER BY 2, 3, 4, 6
) t);
END IF;
END $function$
*/
}
/**
* @function get_geometry_statistics_categories
* @memberof data
* @description Get geometry statistics categories
* @param {text} Params
* @param {integer} PersonId
* @param {integer} LangId
* @returns {json}
*/
function get_geometry_statistics_categories() {
/*
CREATE OR REPLACE FUNCTION data.get_geometry_statistics_categories("Params" text, "PersonId" integer, "LangId" integer)
RETURNS json
LANGUAGE plpgsql
AS $function$
DECLARE
v_indicator_id INTEGER;
BEGIN
v_indicator_id := "Params"::json->>'indicator_id';
RETURN (SELECT json_agg(t) FROM (
SELECT g.id, g.type, g.country, g.name, g.atts, d.name data_source, i.description indicator, g.name || '-' || d.name label, a.name value,
s.*
FROM (
select s.indicator_id, s.parent_id, s.geometry_type_id, s.data_source_id, s.n "total_points", s.n * 0.03 * 0.03 "total_area [km<sup>2</sup>]", t.val, t.freq points, t.freq * 0.03 * 0.03 "area [km<sup>2</sup>]", t.freq * 100. / s.n as percentage
FROM data.geometry_statistics s, LATERAL unnest(x,y) AS t(val, freq)
WHERE s.indicator_id = v_indicator_id
) s
INNER JOIN data.vw_geom g ON g.parent_id = s.parent_id AND g.geometry_type_id = s.geometry_type_id
INNER JOIN data.attribute_description a on a.indicator_id = v_indicator_id and a.value = s.val
INNER JOIN data.indicator i ON i.id = s.indicator_id
INNER JOIN data.data_source d ON d.id = s.data_source_id
) t);
END $function$
*/
}
/**
* @function get_geometry_statistics_single
* @memberof data
* @description Get geometry statistics single
* @param {text} Params
* @param {integer} PersonId
* @param {integer} LangId
* @returns {json}
*/
function get_geometry_statistics_single() {
/*
CREATE OR REPLACE FUNCTION data.get_geometry_statistics_single("Params" text, "PersonId" integer, "LangId" integer)
RETURNS json
LANGUAGE plpgsql
AS $function$
DECLARE v_id INT;
p json;
BEGIN
p := "Params"::json;
RETURN (
SELECT json_agg(t.*) FROM (
SELECT s.id, s.parent_id, d.name data_source, s.indicator_id, i.description indicator, s.data_source_id,s.min, s.max, s.mean, s.median, s.q1, s.q3, s.stdev, s.n, depth.name depth, s.time_span
FROM data.geometry_statistics s
LEFT JOIN data.indicator i ON i.id = s.indicator_id
LEFT JOIN data.data_source d ON d.id = s.data_source_id
LEFT JOIN data.depth depth ON depth.id = s.depth_id
WHERE s.parent_id = (p->>'parent_id')::int AND s.geometry_type_id = (p->>'geometry_type_id')::int
ORDER BY d.name, i.description
) t
);
END $function$
*/
}
/**
* @function get_geometry_type_properties
* @memberof data
* @description Get geometry type properties
* @param {integer} LangId
* @returns {json}
*/
function get_geometry_type_properties() {
/*
CREATE OR REPLACE FUNCTION data.get_geometry_type_properties("LangId" integer)
RETURNS json
LANGUAGE plpgsql
AS $function$
BEGIN
RETURN (
SELECT json_agg(t.*) FROM
(SELECT
g.id value,
g.name label,
json_agg(jsonb_build_object(
'property_id', a.id,
'name', COALESCE(i.name, a.name),
'data_type_id', a.data_type_id,
'unit', COALESCE(ui.name, u.name),
'indicator_id', i.id,
'numerical', COALESCE(i.numerical,a.numerical),
'order_no', p.order_no,
'required', p.required,
'value_from', i.value_from,
'value_to', i.value_to,
'mask', a.mask
)) properties
FROM data.geometry_type g
LEFT JOIN data.geometry_type_property p ON g.id = p.geometry_type_id
LEFT JOIN data.property a ON a.id = p.property_id
LEFT JOIN data.indicator i ON i.id = a.indicator_id
LEFT JOIN catalog.unit u ON u.id = a.unit_id
LEFT JOIN catalog.unit ui ON ui.id = i.unit_id
GROUP BY g.id, g.name
ORDER BY g.name
) t
);
end
$function$
*/
}
/**
* @function get_indicator_legend
* @memberof data
* @description Get indicator legend
* @param {integer} LangId
* @param {integer} IndicatorId
* @returns {json}
*/
function get_indicator_legend() {
/*
CREATE OR REPLACE FUNCTION data.get_indicator_legend("LangId" integer, "IndicatorId" integer)
RETURNS json
LANGUAGE plpgsql
AS $function$
DECLARE v_numerical BOOL;
BEGIN
SELECT numerical INTO v_numerical FROM data.indicator WHERE id = "IndicatorId";
IF (v_numerical) THEN
RETURN (
SELECT json_agg(t.*) FROM (
SELECT '#ffffff' color_code, u.name text, -9999999 value_from
FROM data.indicator v
INNER JOIN catalog.unit u ON u.id = v.unit_id
WHERE v.id = "IndicatorId"
UNION
SELECT
v.color_code,
CASE
WHEN value_from = -999999 THEN '< ' || value_to
WHEN value_to = 999999 THEN '> ' || value_from
ELSE value_from || ' - ' || value_to
END text, value_from
FROM data.vw_indicator_color v
WHERE v.indicator_id = "IndicatorId"
ORDER BY value_from
) t
);
ELSE
RETURN (
SELECT json_agg(t.*) FROM (
SELECT
COALESCE(c.code, '#FF0000') color_code, d.name text
FROM data.attribute_description d
LEFT JOIN general.color c ON c.id = d.color_id
WHERE d.indicator_id = "IndicatorId"
ORDER BY d.name
) t
);
END IF;
END
$function$
*/
}
/**
* @function get_indicator_values
* @memberof data
* @description Get indicator values
* @param {integer} IndicatorId
* @param {integer} DataSourceId
* @returns {Object}
* @property {double_precision} lon
* @property {double_precision} lat
* @property {real} value
* @property {date} date
* @property {character_varying} color_code
* @property {character_varying} point_key
* @property {character} nuts_0
* @property {character_varying} description
* @property {character_varying} point_name
* @property {integer} point_id
*/
function get_indicator_values() {
/*
CREATE OR REPLACE FUNCTION data.get_indicator_values("IndicatorId" integer, "DataSourceId" integer[], "ValueFrom" real, "ValueTo" real, "DepthId" integer)
RETURNS TABLE(lon double precision, lat double precision, value real, date date, color_code character varying, point_key character varying, nuts_0 character, description character varying, point_name character varying, point_id integer, sample integer, has_spectrum boolean, data_source_id integer, depth character varying)
LANGUAGE plpgsql
AS $function$
DECLARE v_numerical BOOL;
v_sql VARCHAR;
BEGIN
IF (
SELECT COUNT(*)
FROM unnest("DataSourceId") AS a(id)
INNER JOIN data.data_source ds ON ds.id = a.id
LEFT JOIN auth.data_source_person dsp ON ds.id = dsp.data_source_id AND dsp.person_id = auth.get_context_person_id()
WHERE ds.public OR dsp.id IS NOT NULL) != array_length("DataSourceId", 1)
THEN
RAISE EXCEPTION 'Not allowed';
end if;
SELECT numerical
INTO v_numerical
FROM data.indicator WHERE id = "IndicatorId";
IF v_numerical = false THEN
RETURN QUERY
SELECT p.lon, p.lat, null::float4 value, m.date, COALESCE(ic.code, '#FF0000'), p.point_key, n.cntr_code, d.name depth, p.name point_name, p.id point_id, p.sample
, EXISTS(SELECT 1 FROM data.spectrum s WHERE s.point_id = id AND s.data_source_id = m.data_source_id) has_spectrum, m.data_source_id, dd.name depth
FROM data.attribute m
INNER JOIN data.point p ON p.id = m.point_id
LEFT JOIN general.nuts n ON n.id = p.l3_id
LEFT JOIN data.attribute_description d ON d.id = m.attribute_description_id
LEFT JOIN data.depth dd ON dd.id = m.depth_id
--LEFT JOIN data.attribute_description d ON d.indicator_id = "IndicatorId" and d.description_id = m.description_id
LEFT JOIN general.color ic ON ic.id = d.color_id
WHERE m.indicator_id = "IndicatorId" AND m.data_source_id = ANY("DataSourceId") AND m.depth_id = "DepthId"
ORDER BY d.name
;
ELSE
RETURN QUERY
SELECT t.lon, t.lat, avg(t.value)::float4 value, t.date, t.color_code, t.point_key, t.cntr_code, t.description, t.point_name, t.point_id, t.sample
, EXISTS(SELECT 1 FROM data.spectrum s WHERE s.point_id = t.point_id AND s.data_source_id = t.data_source_id) has_spectrum, t.data_source_id, t.depth
FROM (
SELECT p.lon, p.lat, m.value, m.date, ic.color_code, p.point_key, n.cntr_code, null::varchar description, d.name depth, p.name point_name, p.id point_id, p.sample,
ROW_NUMBER() OVER (PARTITION BY m.point_id, m.indicator_id, m.depth_id ORDER BY m.date DESC, d.name) nr, m.data_source_id
FROM data.measurement m
INNER JOIN data.point p ON p.id = m.point_id
LEFT JOIN data.depth d ON d.id = m.depth_id
LEFT JOIN general.nuts n ON n.id = p.l3_id
LEFT JOIN data.vw_indicator_color ic
ON m.value > ic.value_from AND m.value <= ic.value_to AND ic.indicator_id = m.indicator_id
WHERE m.indicator_id = "IndicatorId" AND m.data_source_id = ANY("DataSourceId") AND m.value >= COALESCE("ValueFrom", -9999999) AND m.value <= COALESCE("ValueTo", 9999999) AND m.depth_id = "DepthId"
) t WHERE t.nr = 1
GROUP BY t.lon, t.lat, t.date, t.color_code, t.point_key, t.cntr_code, t.description, t.point_name, t.point_id, t.sample, t.data_source_id, t.depth
ORDER BY value
;
END IF;
END
$function$
*/
}
/**
* @function get_indicators_by_nuts
* @memberof data
* @description Get indicators by NUTS
* @param {text} Params
* @param {integer} PersonId
* @param {integer} LangId
* @returns {Object}
* @property {integer} levl_code
* @property {character_varying} country
* @property {character_varying} name_latn
* @property {character_varying} nuts_id
* @property {character_varying} indicator
* @property {numeric} average
* @property {numeric} min
* @property {numeric} max
*/
function get_indicators_by_nuts() {
/*
CREATE OR REPLACE FUNCTION data.get_indicators_by_nuts("Params" text, "PersonId" integer, "LangId" integer)
RETURNS TABLE(levl_code integer, country character varying, name_latn character varying, nuts_id character varying, indicator character varying, average numeric, min numeric, max numeric)
LANGUAGE plpgsql
AS $function$
BEGIN
RETURN QUERY
SELECT v.levl_code, c.name_latn, n.name_latn, n.nuts_id, i.description, v.value_avg::decimal(10,2), v.value_min::decimal(10,2), v.value_max::decimal(10,2)
FROM data.vw_avg_indicator_values_by_nuts v
INNER JOIN general.nuts n ON n.nuts_id = v.nuts_id
INNER JOIN data.indicator i ON i.id = v.indicator_id
INNER JOIN general.nuts c ON c.nuts_id = n.cntr_code
WHERE v.data_source_id = (("Params"::json)->>'data_source_id')::INT
ORDER BY 1, 2, 3, 4, 5;
END $function$
*/
}
/**
* @function get_indicators_for_data_source
* @memberof data
* @description Get indicators for data source
* @param {integer} DataSourceId
* @param {integer} LangId
* @returns {json}
*/
function get_indicators_for_data_source() {
/*
CREATE OR REPLACE FUNCTION data.get_indicators_for_data_source("DataSourceId" integer[], "LangId" integer)
RETURNS json
LANGUAGE plpgsql
AS $function$
BEGIN
RETURN (
SELECT json_agg(t.*) FROM (
SELECT DISTINCT i.id value, COALESCE (l.value, e.value, i.display_name) label,
i.numerical, u.display_name unit, i.decimals_for_stats, i.decimals_for_display,
jsonb_agg(
jsonb_build_object(
'value', v.depth_id,
'label', COALESCE (d.name, '-') || ' (' || v.n::text || ')',
'name', COALESCE(d.name, '-')
)
ORDER BY v.n DESC
) depths
FROM data.vw_data_source_indicator v
LEFT JOIN data.indicator i ON i.id = v.indicator_id
LEFT JOIN data.indicator_lang l on l.indicator_id = i.id and l.lang_id = "LangId"
LEFT JOIN data.indicator_lang e on e.indicator_id = i.id and e.lang_id = "LangId"
LEFT JOIN catalog.unit u ON u.id = i.unit_id
LEFT JOIN data.depth d ON d.id = v.depth_id
WHERE v.data_source_id = ANY("DataSourceId")
GROUP BY i.id, l.value, e.value, i.display_name, u.display_name, i.numerical, i.decimals_for_stats, i.decimals_for_display
ORDER BY 2) t
);
END
$function$
*/
}
/**
* @function get_indicators_table
* @memberof data
* @description Get indicators in table format
* @param {text} Params
* @param {integer} PersonId
* @param {integer} LangId
* @returns {json}
*/
function get_indicators_table() {
/*
CREATE OR REPLACE FUNCTION data.get_indicators_table("Params" text, "PersonId" integer, "LangId" integer)
RETURNS json
LANGUAGE plpgsql
AS $function$
BEGIN
RETURN (
SELECT json_agg(t.*) FROM (
--SELECT COALESCE(i.name, l.value) Indicator, u.name unit, i.*
SELECT i.*, u.name unit
FROM data.indicator i
LEFT JOIN catalog.unit u ON u.id = i.unit_id
--LEFT JOIN data.indicator_lang l ON l.indicator_id = i.id AND l.lang_id = "LangId"
ORDER BY name
) t
);
END $function$
*/
}
/**
* @function get_intersecting_geometries
* @memberof data
* @description Get intersecting geometries
* @param {text} Params
* @param {integer} PersonId
* @param {integer} LangId
* @returns {json}
*/
function get_intersecting_geometries() {
/*
CREATE OR REPLACE FUNCTION data.get_intersecting_geometries("Params" text, "PersonId" integer, "LangId" integer)
RETURNS json
LANGUAGE plpgsql
AS $function$
DECLARE v_geom geometry;
json json;
v_id INT;
v_indicator_id INT;
v_geometry_type_id INT;
BEGIN
json = "Params"::json;
v_id = (json->>'id')::INT;
v_indicator_id = (json->>'indicator_id')::INT;
v_geometry_type_id = (json->>'geometry_type_id')::INT;
IF v_geometry_type_id = 5 THEN
SELECT st_transform(g.geometry, 3035) INTO v_geom FROM data.field_boundary g WHERE ogc_fid = v_id;
ELSE
SELECT st_transform(g.geom, 3035) INTO v_geom FROM data.vw_geometry g WHERE parent_id = v_id AND geometry_type_id = v_geometry_type_id;
END IF;
RETURN json_agg(t) FROM (
SELECT gs.id, a.key name, ds.name data_source, a.key || ' ' || ds.name label, gs.*, d.name depth
FROM data.geometry g
INNER JOIN data.aggregate_region a ON a.id = g.parent_id
LEFT JOIN data.geometry_statistics gs ON gs.geometry_type_id = g.geometry_type_id AND gs.parent_id = a.id AND gs.indicator_id = v_indicator_id
LEFT JOIN data.data_source ds ON ds.id = gs.data_source_id
LEFT JOIN data.depth d ON gs.depth_id = d.id
WHERE g.geometry_type_id = 4 AND ST_Intersects(v_geom, g.geom)
UNION
SELECT gs.id,n.name_latn, ds.name data_source, n.name_latn || ' ' || ds.name label, gs.*, d.name depth
FROM general.nuts n
LEFT JOIN data.geometry_statistics gs ON gs.geometry_type_id = 2 AND gs.parent_id = n.id AND gs.indicator_id = v_indicator_id
LEFT JOIN data.data_source ds ON ds.id = gs.data_source_id
LEFT JOIN data.depth d ON gs.depth_id = d.id
WHERE ST_Intersects(v_geom, n.geom)
ORDER BY name, data_source, depth
) t;
END $function$
*/
}
/**
* @function get_nuts_overload
* @overload get_nuts
* @memberof data
* @description Get NUTS regions by level, zoom and bounding box
* @param {integer} Level
* @param {integer} Srid
* @param {integer} Zoom
* @param {double_precision} MinX
* @param {double_precision} MinY
* @param {double_precision} MaxX
* @param {double_precision} MaxY
* @param {integer} IndicatorId
* @param {integer} DataSourceId
* @returns {json}
*/
function get_land_use_boundaries() {
/*
CREATE OR REPLACE FUNCTION data.get_land_use_boundaries("Srid" integer, "Extent" character varying)
RETURNS json
LANGUAGE plpgsql
AS $function$
DECLARE bb geometry;
simplify float;
-- SELECT * FROM data.get_nuts(0, 3035, 10, 2217542.415101382,1337159.7278276538,6191714.062701465,4547067.5970431045, 1)
BEGIN
bb := general.envelope ("Extent", "Srid");
bb := st_transform(bb, 3035);
RAISE NOTICE 'bb: %', bb;
RETURN (
SELECT json_build_object (
'type', 'FeatureCollection',
'features', json_agg(st_asgeojson(t.*)::json)
)
FROM (
SELECT b.ogc_fid key, 6 geometry_type_id, st_transform(b.geometry, "Srid") geometry
FROM data.land_use_boundary b
WHERE st_intersects(b.geometry, bb)
) t
);
END
$function$
*/
}
/**
* @function get_locations
* @memberof data
* @description Get locations by person id
* @param {text} Params
* @param {integer} PersonId
* @param {integer} LangId
* @returns {Object}
* @property {integer} id
* @property {character_varying} name
* @property {character_varying} type
* @property {boolean} public
*/
function get_locations() {
/*
CREATE OR REPLACE FUNCTION data.get_locations("Params" text, "PersonId" integer, "LangId" integer)
RETURNS TABLE(id integer, name character varying, time_created timestamp with time zone)
LANGUAGE plpgsql
AS $function$
BEGIN
RETURN QUERY (
SELECT f.id, f.name, f.time_created --, f.time_modified
FROM data.custom_geometry f
INNER JOIN auth.vw_partner vp ON vp.user_id = f.person_id AND vp.partner_user_id = "PersonId"
ORDER BY f.time_created DESC
);
END
$function$
*/
}
/**
* @function get_lucas
* @memberof data
* @description Get LUCAS data
* @param {text} Params
* @param {integer} PersonId
* @param {integer} LangId
* @returns {Object}
* @property {character_varying} Point
* @property {character_varying} Depth
* @property {double_precision} OxAl
* @property {double_precision} N
* @property {double_precision} P
* @property {double_precision} OxFe
* @property {double_precision} pH_(CaCl<sub>2</sub>)
* @property {double_precision} EC
* @property {double_precision} K
* @property {double_precision} OC
* @property {double_precision} pH_(H<sub>2</sub>O)
* @property {double_precision} CaCO<sub>3</sub>
* @property {character_varying} Nuts_0
* @property {character_varying} Nuts_1
* @property {character_varying} Nuts_2
* @property {character_varying} Nuts_3
* @property {double_precision} Lat
* @property {double_precision} Lon
* @property {date} Date
* @property {integer} Elevation
* @property {character_varying} Land_cover
* @property {character_varying} Land_usage
* @property {character_varying} Main_land_cover
* @property {character_varying} Detailed_land_cover
* @property {character_varying} Detailed_land_use
*/
function get_lucas() {
/*
CREATE OR REPLACE FUNCTION data.get_lucas("Params" text, "PersonId" integer, "LangId" integer)
RETURNS TABLE("Point" character varying, "Depth" character varying, "OxAl" double precision, "N" double precision, "P" double precision, "OxFe" double precision, "pH (CaCl<sub>2</sub>)" double precision, "EC" double precision, "K" double precision, "OC" double precision, "pH (H<sub>2</sub>O)" double precision, "CaCO<sub>3</sub>" double precision, "Nuts_0" character varying, "Nuts_1" character varying, "Nuts_2" character varying, "Nuts_3" character varying, "Lat" double precision, "Lon" double precision, "Date" date, "Elevation" integer, "Land cover" character varying, "Land usage" character varying, "Main land cover" character varying, "Detailed land cover" character varying, "Detailed land use" character varying)
LANGUAGE plpgsql
AS $function$
DECLARE v_data_source_id INT;
v_params json;
BEGIN
v_params = "Params"::json;
IF v_params->>'data_source_id' IS NULL THEN
v_data_source_id = 1;
ELSE
v_data_source_id = (v_params->>'data_source_id')::INT;
END IF;
RETURN QUERY (
SELECT p.point_key, d.name depth
, t."Ox_Al", t."N", t."P", t."Ox_Fe", t."pH (CaCl2)", t."EC", t."K", t."OC", t."pH (H2O)", t."CaCO3"
, n0.nuts_id nuts_0, n1.nuts_id nuts_1, n2.nuts_id nuts_2, n3.nuts_id nuts_3, p.lat, p.lon, t.date, p.elev
, lcd.code::VARCHAR lc, lud.code::VARCHAR lu, lcm.name lc0_desc, lcd.name lc1_desc, lud.name lu1_desc
FROM (
SELECT * FROM crosstab (
'SELECT p.id, m.date, m.depth_id, i.name, m.value
from data.measurement m
INNER JOIN data.indicator i on i.id = m.indicator_id
INNER JOIN data.point p on p.id = m.point_id WHERE m.data_source_id = ' || v_data_source_id || ' ORDER BY 1, 2',
'SELECT DISTINCT i.name FROM data.indicator i inner join data.measurement m on m.indicator_id = i.id AND m.data_source_id = ' || v_data_source_id
) AS ct (id int, date date, depth_id int, "Ox_Al" float, "N" float, "P" float, "Ox_Fe" float, "pH (CaCl2)" float, "EC" float, "K" float, "OC" float, "pH (H2O)" float, "CaCO3" float)
) t
INNER JOIN data.point p on p.id = t.id
LEFT JOIN data.vw_nuts v ON v.l3_id = p.l3_id
LEFT JOIN general.nuts n0 ON n0.id = v.l0_id
LEFT JOIN general.nuts n1 ON n1.id = v.l1_id
LEFT JOIN general.nuts n2 ON n2.id = v.l2_id
LEFT JOIN general.nuts n3 ON n3.id = v.l3_id
LEFT JOIN data.attribute a_lcd ON a_lcd.indicator_id = 14 and a_lcd.point_id = p.id and a_lcd.data_source_id = v_data_source_id
LEFT JOIN data.attribute a_lcm ON a_lcm.indicator_id = 15 and a_lcm.point_id = p.id and a_lcm.data_source_id = v_data_source_id
LEFT JOIN data.attribute a_lud ON a_lud.indicator_id = 16 and a_lud.point_id = p.id and a_lud.data_source_id = v_data_source_id
LEFT JOIN data.depth d ON d.id = t.depth_id
-- LEFT JOIN data.attribute_description lcm
-- ON lcm.indicator_id = a_lcm.indicator_id AND lcm.description_id = a_lcm.description_id
-- LEFT JOIN data.attribute_description lcd
-- ON lcd.indicator_id = a_lcd.indicator_id AND lcd.description_id = a_lcd.description_id
-- LEFT JOIN data.attribute_description lud ON
-- lud.indicator_id = a_lud.indicator_id AND lud.description_id = a_lud.description_id
LEFT JOIN data.attribute_description lcm
ON lcm.id = a_lcm.attribute_description_id
LEFT JOIN data.attribute_description lcd
ON lcd.id = a_lcd.attribute_description_id
LEFT JOIN data.attribute_description lud
ON lud.id = a_lud.attribute_description_id
ORDER BY 2
-- ) t
);
END $function$
*/
}
/**
* @function get_nuts_overload
* @overload get_nuts
* @memberof data
* @description Get NUTS regions by level, zoom and bounding box
* @param {integer} Level
* @param {integer} Srid
* @param {integer} Zoom
* @param {varchar} Extent
* @param {integer} IndicatorId
* @param {integer} DataSourceId
* @returns {json}
*/
function get_nuts_overload_overload_boundaries() {
/*
CREATE OR REPLACE FUNCTION data.get_nuts_boundaries("Level" integer, "Srid" integer, "Zoom" integer, "Extent" character varying, "IndicatorId" integer, "DataSourceId" integer[], "DepthId" integer)
RETURNS json
LANGUAGE plpgsql
AS $function$
DECLARE bb geometry;
simplify float;
-- SELECT * FROM data.get_nuts(0, 3035, 10, 2217542.415101382,1337159.7278276538,6191714.062701465,4547067.5970431045, 1)
BEGIN
bb := general.envelope ("Extent", "Srid");
bb := st_transform(bb, 3035);
simplify := general.simplify("Zoom");
RETURN (
SELECT jsonb_build_object (
'type', 'FeatureCollection',
'features', json_agg(st_asgeojson(t.*)::json)
)
FROM (
SELECT b.id, b.nuts_name name, b.levl_code, v.n, ROUND(v.mean::numeric,2) value, v.min, v.q1, ROUND(v.mean::numeric,2), v.median, v.q3, v.max, v.stdev, '#FF0000' color_code, COALESCE(ic.color_code, '#FFFFFF') || '3f' fill_color_code,-- u.name unit_name,
st_transform(st_simplify(b.geom, simplify, false), "Srid")
FROM general.nuts b
LEFT JOIN data.geometry_statistics v ON v.parent_id = b.id AND v.indicator_id = "IndicatorId" AND v.data_source_id = ANY("DataSourceId") AND v.depth_id = "DepthId"
--LEFT JOIN data.vw_avg_indicator_values_by_nuts v ON b.nuts_id = v.nuts_id AND v.indicator_id = "IndicatorId" AND v.data_source_id = ANY("DataSourceId")
LEFT JOIN data.vw_indicator_color ic
ON ic.indicator_id = v.indicator_id AND ic.value_from < v.mean AND ic.value_to >= v.mean
WHERE b.levl_code = "Level" AND st_intersects(b.geom, bb)
) t
);
END
$function$
*/
}
/**
* @function get_point_history
* @memberof data
* @description Get point history
* @param {integer} PointId
* @param {integer} IndicatorId
* @returns {Object}
* @property {date} date
* @property {character_varying} depth
* @property {real} value
*/
function get_point_history() {
/*
CREATE OR REPLACE FUNCTION data.get_point_history("PointId" integer, "IndicatorId" integer)
RETURNS TABLE(date date, depth character varying, value real)
LANGUAGE plpgsql
AS $function$
BEGIN
-- Routine body goes here...
RETURN QUERY (
SELECT m.date date, d.name depth, m.value
FROM data.measurement m
LEFT JOIN data.depth d ON d.id = m.depth_id
WHERE m.indicator_id = "IndicatorId" AND m.point_id = "PointId"
ORDER BY 1, 2
);
END
$function$
*/
}
/**
* @function get_prediction_model_data
* @memberof data
* @description Get prediction model binary data
* @param {integer} PredictionModelId
* @returns {bytea}
*/
function get_prediction_model_data() {
/*
CREATE OR REPLACE FUNCTION data.get_prediction_model_data("PredictionModelId" integer)
RETURNS bytea
LANGUAGE plpgsql
AS $function$BEGIN
RETURN (
SELECT model FROM data.prediction_model
WHERE id = "PredictionModelId"
);
END $function$
*/
}
/**
* @function get_prediction_models_for_data_source
* @memberof data
* @description Get prediction models for data source
* @param {integer} DataSourceId
* @param {integer} LangId
* @returns {json}
*/
function get_prediction_models_for_data_source() {
/*
CREATE OR REPLACE FUNCTION data.get_prediction_models_for_data_source("DataSourceId" integer, "LangId" integer)
RETURNS json
LANGUAGE plpgsql
AS $function$BEGIN
RETURN (
SELECT json_agg(t.*) FROM (
SELECT pm.id, pm.method, i.name as indicator_name, i.display_name as indicator_display_name
FROM data.prediction_model pm
INNER JOIN data.indicator i ON i.id = pm.indicator_id
) t
);
END $function$
*/
}
/**
* @function get_assets_overload
* @overload get_assets
* @memberof data
* @description Get assets
* @param {integer} TitleId
* @param {character_varying} Depth
* @param {integer} Srid
* @returns {json}
*/
function get_shdc_files() {
/*
CREATE OR REPLACE FUNCTION data.get_shdc_files("TitleId" integer, "Depth" character varying, "Confidence" character varying)
RETURNS json
LANGUAGE plpgsql
AS $function$
BEGIN
-- Routine body goes here...
RETURN (
SELECT json_agg(t.*)
FROM (
SELECT row_number() OVER (ORDER BY temporal_coverage_start || '-' || temporal_coverage_end DESC) value,
temporal_coverage_start || '-' || temporal_coverage_end label,
'image/tiff' type,
wasabi_link source,
s.indicator_id,
"Depth" depth,
"Confidence" confidence
FROM data.shdc_file f
LEFT JOIN data.shdc s ON s.id = f.shdc_id
LEFT JOIN data.depth d ON d.id = f.depth_id
WHERE f.shdc_id = "TitleId" and (d.name = "Depth" or "Depth" is null) and (f.value = "Confidence" or "Confidence" is null)
ORDER BY temporal_coverage_start DESC, f.value
) t
);
END
$function$
*/
}
/**
* @function get_single_geometry
* @memberof data
* @description Get single geometry
* @param {integer} Id
* @returns {json}
*/
function get_single_geometry() {
/*
CREATE OR REPLACE FUNCTION data.get_single_geometry("Id" integer)
RETURNS json
LANGUAGE plpgsql
AS $function$
DECLARE result json;
BEGIN
result := (
SELECT row_to_json(t) FROM (
SELECT cg.id AS id, cg.name, cg.geometry, cg.time_created, (
SELECT json_agg(so.*) FROM (
SELECT so.id, so.name, so.comment, so.indicator_id, so.date, so.value, j.name indicator, so.custom_geometry_id, (
SELECT json_agg(i.*) FROM (
SELECT i.id, i.name, i.compass, i.extension, i.lat, i.lon, i.mime_type, i.simple_observation_id
FROM data.image i
WHERE i.simple_observation_id = so.id
) i
) images
FROM data.simple_observation so
LEFT JOIN data.indicator j ON so.indicator_id = j.id
WHERE so.custom_geometry_id = cg.id
ORDER BY so.date DESC
) so
) simple_observations
FROM data.custom_geometry cg
WHERE cg.id = "Id"
) t
);
RETURN result;
END $function$
*/
}
/**
* @function get_shape_geometry_overload
* @overload get_shape_geometry
* @memberof data
* @description Get site geometry
* @param {integer} Id
* @returns {json}
*/
function get_site_points() {
/*
CREATE OR REPLACE FUNCTION data.get_site_points("Id" integer)
RETURNS json
LANGUAGE plpgsql
AS $function$
BEGIN
RETURN (
SELECT jsonb_build_object (
'type', 'FeatureCollection',
'features', json_agg(
json_build_object(
'id', 'sp' || t.id::VARCHAR,
'type', 'Feature',
'geometry', st_setsrid(t.geom, 4326),
'properties', json_build_object(
'key', id,
'name', t.name,
'editor', 'single-row-editor',
'tableAPI', 'data_point')
)
)
)
FROM (
SELECT p.id, p.name, st_makepoint(p.lon, p.lat) AS geom
FROM data.point p
WHERE p.site_id = "Id"
) t
);
END$function$
*/
}
/**
* @function get_shapes_for_data_source
* @memberof data
* @description Get shapes for data source
* @param {integer} DataSourceId
* @returns {json}
*/
function get_sites_for_data_source() {
/*
CREATE OR REPLACE FUNCTION data.get_sites_for_data_source("DataSourceId" integer[])
RETURNS json
LANGUAGE plpgsql
AS $function$
BEGIN
RETURN (
SELECT json_agg(t.*) FROM (
SELECT id value, name label
FROM data.site
WHERE data_source_id = ANY("DataSourceId")
ORDER BY 2
) t
);
END
$function$
*/
}
/**
* @function get_spectra_for_data_source
* @memberof data
* @description Get spectra for data source
* @param {text} Params
* @param {integer} PersonId
* @param {integer} LangId
* @returns {Object} character_varying namedate datesmallint[] wavelengthsreal[] values
*/
function get_spectra_for_data_source() {
/*
CREATE OR REPLACE FUNCTION data.get_spectra_for_data_source("Params" text, "PersonId" integer, "LangId" integer)
RETURNS TABLE(name character varying, date date, wavelengths smallint[], "values" real[])
LANGUAGE plpgsql
AS $function$
BEGIN
RETURN QUERY
SELECT COALESCE(p.sample::varchar, p.name, p.point_key) name, t."date", t.wavelengths, t."values"
FROM data.spectrum t
INNER JOIN data.point p ON t.point_id = p.id
WHERE t.data_source_id = (("Params"::json)->>'data_source_id')::integer;
END $function$
*/
}
/**
* @function get_spectrum
* @memberof data
* @description Get spectrum
* @param {integer} DataSourceId
* @param {integer} PointId
* @param {timestamp_without_time_zone} Date
* @returns {Object} smallint wavelengthreal value
*/
function get_spectrum() {
/*
CREATE OR REPLACE FUNCTION data.get_spectrum("DataSourceId" integer, "PointId" integer, "Date" timestamp without time zone)
RETURNS TABLE(wavelength smallint, value real)
LANGUAGE plpgsql
AS $function$
BEGIN
RETURN QUERY (
SELECT t.wavelength, t.value
FROM data.spectrum s,
LATERAL unnest(wavelengths, values) AS t (wavelength, value)
WHERE s.point_id = "PointId"
AND s.data_source_id = "DataSourceId"
AND s.date = "Date"
);
END $function$
*/
}
/**
* @function get_taxa_children
* @memberof data
* @description Get taxa children
* @param {text} Params
* @param {integer} PersonId
* @param {integer} LangId
* @returns {json}
*/
function get_taxa_children() {
/*
CREATE OR REPLACE FUNCTION data.get_taxa_children("Params" text, "PersonId" integer, "LangId" integer)
RETURNS json
LANGUAGE plpgsql
AS $function$
BEGIN
RETURN json_agg(t) FROM (
SELECT t.id, t.latin_name, l.name || CASE WHEN (t.synonym) THEN ', synonym' ELSE '' END level, count (*) filter (where c.id is not null) n_children
FROM data.taxa t
INNER JOIN catalog.taxa_level l ON t.taxa_level_id = l.id
LEFT JOIN data.taxa c ON c.parent_id = t.id
WHERE t.parent_id = (("Params"::json)->>'id')::int
GROUP BY t.id, t.latin_name, l.name, t.synonym
) t;
END $function$
*/
}
/**
* @function get_taxa_hierarchy
* @memberof data
* @description Get taxa hierarchy
* @param {text} Params
* @param {integer} PersonId
* @param {integer} LangId
* @returns {json}
*/
function get_taxa_hierarchy() {
/*
CREATE OR REPLACE FUNCTION data.get_taxa_hierarchy("Params" text, "PersonId" integer, "LangId" integer)
RETURNS json
LANGUAGE plpgsql
AS $function$
DECLARE r text;
v_id int;
BEGIN
v_id = ("Params"::json)->>'taxa_id';
WITH RECURSIVE th AS (
SELECT t.id, t.latin_name, t.parent_id, l.name || CASE WHEN t.synonym THEN ', synonym' ELSE '' END as level,
t.link, t.env, t.reference, t.remarks, t.chrono, t.extinct, t.uncertain, 1 as recursion_level
FROM data.taxa t
LEFT JOIN catalog.taxa_level l ON l.id = t.taxa_level_id
WHERE t.id = v_id
UNION ALL
SELECT t.id, t.latin_name, t.parent_id, l.name || CASE WHEN t.synonym THEN ', synonym' ELSE '' END as level,
t.link, t.env, t.reference, t.remarks, t.chrono, t.extinct, t.uncertain, th.recursion_level + 1
FROM data.taxa t
LEFT JOIN catalog.taxa_level l ON l.id = t.taxa_level_id
INNER JOIN th
ON t.id = th.parent_id
),
max_rec AS (
SELECT MAX(recursion_level) AS max_level FROM th
),
r0 AS (
SELECT
th.*,
repeat('..', (max_rec.max_level - th.recursion_level) * 2) || th.latin_name AS indented_name
FROM th, max_rec
)
SELECT json_agg(r0 ORDER BY r0.recursion_level DESC) INTO r FROM r0;
-- SELECT json_agg(th ORDER BY recursion_level DESC) INTO r FROM th; -- GROUP BY th.recursion_level ORDER BY th.recursion_level desc;
RETURN r;
END $function$
*/
}
/**
* @function get_taxa_hierarchy_overload
* @overload get_taxa_hierarchy
* @memberof data
* @description Get taxa hierarchy
* @param {text} Params
* @returns {json}
*/
function get_taxa_hierarchy_overload() {
/*
CREATE OR REPLACE FUNCTION data.get_taxa_hierarchy("Params" text)
RETURNS json
LANGUAGE plpgsql
AS $function$
DECLARE r text;
v_id int;
BEGIN
v_id = ("Params"::json)->>'Id';
WITH RECURSIVE th AS (
SELECT t.id, t.latin_name, t.parent_id, l.name as level
FROM data.taxa t
LEFT JOIN catalog.taxa_level l ON l.id = t.taxa_level_id
WHERE t.id = v_id
UNION ALL
-- Recursive case: Find all children of the current category
SELECT t.id, t.latin_name, t.parent_id, l.name as level
FROM data.taxa t
LEFT JOIN catalog.taxa_level l ON l.id = t.taxa_level_id
INNER JOIN th
ON t.id = th.parent_id
)
SELECT json_agg(th.*) INTO r FROM th;
RETURN r;
END $function$
*/
}
/**
* @function get_tile_layers
* @memberof data
* @description Get tile layers
* @param {integer} Srid
* @returns {Object}
* @property {integer} fid
* @property {character_varying} collection_title
* @property {character_varying} href
* @property {character_varying} type
* @property {text} geom
*/
function get_tile_layers() {
/*
CREATE OR REPLACE FUNCTION data.get_tile_layers("Srid" integer)
RETURNS TABLE(fid integer, collection_title character varying, href character varying, type character varying, geom text)
LANGUAGE plpgsql
AS $function$
BEGIN
RETURN QUERY
SELECT * FROM (
select 0 fid, ' OSM' collection_title, '' href, 'OSM' type, null geom
UNION
select t.fid, t.collection_title, t.href, t.type, ST_AsGeoJSON(ST_Transform(t.geom, "Srid"), 6, 1) geom from data.oedce t
where t."type" LIKE '%tiff%'
) t
ORDER BY t.collection_title COLLATE "C";
END $function$
*/
}
/**
* @function get_titles
* @memberof data
* @description Get titles
* @returns {json}
*/
function get_titles() {
/*
CREATE OR REPLACE FUNCTION data.get_titles()
RETURNS json
LANGUAGE plpgsql
AS $function$
BEGIN
-- Routine body goes here...
RETURN (
SELECT json_agg(t.*)
FROM (
--SELECT a.id value, title label, main_sld_url sld, color_map, scale_factor, no_data, depth_list, decimals, av.srid
--FROM data.asset a
--LEFT JOIN catalog.asset_version av ON av.id = a.asset_version_id
--WHERE main_url IS NOT NULL
--ORDER BY 2
SELECT
a.id value,
i.display_name label,
depth_list,
color_map,
scale_factor::varchar,
no_data,
1 decimals,
3035 srid,
i.numerical,
--( SELECT json_object_agg(t.value, json_build_object('name', t.name, 'color_code', COALESCE (c.code, '#FF0000') ))
-- FROM data.attribute_description t
-- LEFT JOIN general.color c ON c.id = t.color_id
-- WHERE t.indicator_id = a.indicator_id AND NOT i.numerical
--) description,
confidence_list,
u.display_name,
a.max_zoom,
a.custom_restricted_api,
i.id indicator_id
FROM data.shdc a
INNER JOIN data.indicator i ON i.id = a.indicator_id
LEFT JOIN catalog.unit u on a.unit_id = u.id
--LEFT JOIN catalog.asset_version av ON av.id = a.asset_version_id
--WHERE main_url IS NOT NULL
ORDER BY 2
) t
);
END
$function$
*/
}
/**
* @function get_vw_assets
* @memberof data
* @description Get vw assets
* @returns {json}
*/
function get_vw_assets() {
/*
CREATE OR REPLACE FUNCTION data.get_vw_assets()
RETURNS json
LANGUAGE plpgsql
AS $function$
BEGIN
RETURN json_agg(t) FROM (
SELECT * FROM data.vw_asset
) t;
END $function$
*/
}
/**
* @function import_croatia
* @memberof data
* @description Import croatia data from json (excel)
* @param {text} jsonCV
* @param {text} jsonData
* @returns {void}
*/
function import_croatia() {
/*
CREATE OR REPLACE FUNCTION data.import_croatia("Params" text, "jsonData" text)
RETURNS void
LANGUAGE plpgsql
AS $function$
BEGIN
DROP TABLE IF EXISTS t;
CREATE TEMP TABLE t AS
SELECT * FROM json_to_recordset("jsonData"::json) AS J(
"Year" varchar, "Datex" varchar, "depth" varchar, "pH" varchar, "EC (mS/m)" varchar, "point_key" varchar, "y" varchar, "x" varchar, "date" varchar);
WITH x AS (SELECT DISTINCT t."depth" FROM t)
INSERT INTO data.depth(name)
SELECT meta.clean_value(x."depth", 'varchar')::varchar FROM x
LEFT JOIN data.depth depth ON depth.name= x."depth"
WHERE depth.id IS NULL;
WITH x AS (SELECT DISTINCT t."point_key", t."y", t."x" FROM t)
INSERT INTO data.point(point_key, x, y, name, data_source_id)
SELECT meta.clean_value(x."point_key", 'varchar')::varchar, meta.clean_value(x."y", 'double precision')::double precision, meta.clean_value(x."x", 'double precision')::double precision, 'Glog', 4 FROM x
LEFT JOIN data.point point ON point.point_key= x."point_key"
WHERE point.id IS NULL;
INSERT INTO data.measurement(point_id, indicator_id, depth_id, value, date, data_source_id)
SELECT x.id, i.id, d.id, meta.clean_value(t."pH", 'double precision')::double precision, meta.clean_value(t.date, 'date')::date, 4 FROM t
LEFT JOIN data.point x ON x.point_key = t."point_key"
left join data.indicator i on i.name_match = 'pHe' left join data.measurement y on y.point_id = x.id and y.indicator_id = i.id and y.date = meta.clean_value(t.date, 'date')::date left join data.depth d on d.name = t.depth
WHERE y.id IS NULL AND meta.clean_value(t."pH", 'double precision')::double precision IS NOT NULL ;
INSERT INTO data.measurement(point_id, indicator_id, depth_id, value, date, data_source_id)
SELECT x.id, i.id, d.id, meta.clean_value(t."EC (mS/m)", 'double precision')::double precision, meta.clean_value(t.date, 'date')::date, 4 FROM t
LEFT JOIN data.point x ON x.point_key = t."point_key"
left join data.indicator i on i.name_match = 'ECe' left join data.measurement y on y.point_id = x.id and y.indicator_id = i.id and y.date = meta.clean_value(t.date, 'date')::date left join data.depth d on d.name = t.depth
WHERE y.id IS NULL AND meta.clean_value(t."EC (mS/m)", 'double precision')::double precision IS NOT NULL ;
END $function$
*/
}
/**
* @function import_croatia246
* @memberof data
* @description Import croatia246 data from json (excel) file
* @param {text} jsonCV
* @param {text} jsonData
* @returns {void}
*/
function import_croatia246() {
/*
CREATE OR REPLACE FUNCTION data.import_croatia246("jsonCV" text, "jsonData" text)
RETURNS void
LANGUAGE plpgsql
AS $function$
BEGIN
DROP TABLE IF EXISTS t;
CREATE TEMP TABLE t AS
SELECT * FROM json_to_recordset("jsonData"::json) AS J(
"y" varchar, "x" varchar, "pH" varchar, "EC (dS/m) " varchar, "EC (mS/m)" varchar, "Clay" varchar, "CEC" varchar, "Point_key" varchar);
WITH x AS (SELECT DISTINCT t."y", t."x", t."Point_key" FROM t)
INSERT INTO data.point(y, x, point_key, data_source_id)
SELECT meta.clean_value(x."y", 'double precision')::double precision, meta.clean_value(x."x", 'double precision')::double precision, meta.clean_value(x."Point_key", 'varchar')::varchar, 4 FROM x
LEFT JOIN data.point point ON point.point_key= x."Point_key"
WHERE point.id IS NULL;
INSERT INTO data.measurement(point_id, indicator_id, value, date, data_source_id)
SELECT x.id, i.id, meta.clean_value(t."pH", 'double precision')::double precision, '2011-12-31'::date, 4 FROM t
LEFT JOIN data.point x ON x.point_key = t."Point_key"
left join data.indicator i on i.name_match = 'pHe' left join data.measurement y on y.point_id = x.id and y.indicator_id = i.id and y.date = '2011-12-31'::date
WHERE y.id IS NULL AND meta.clean_value(t."pH", 'double precision')::double precision IS NOT NULL ;
INSERT INTO data.measurement(point_id, indicator_id, value, date, data_source_id)
SELECT x.id, i.id, meta.clean_value(t."EC (mS/m)", 'double precision')::double precision, '2011-12-31'::date, 4 FROM t
LEFT JOIN data.point x ON x.point_key = t."Point_key"
left join data.indicator i on i.name_match = 'ECe' left join data.measurement y on y.point_id = x.id and y.indicator_id = i.id and y.date = '2011-12-31'::date
WHERE y.id IS NULL AND meta.clean_value(t."EC (mS/m)", 'double precision')::double precision IS NOT NULL ;
INSERT INTO data.measurement(point_id, indicator_id, value, date, data_source_id)
SELECT x.id, i.id, meta.clean_value(t."Clay", 'double precision')::double precision, '2011-12-31'::date, 4 FROM t
LEFT JOIN data.point x ON x.point_key = t."Point_key"
left join data.indicator i on i.name_match = 'Clay' left join data.measurement y on y.point_id = x.id and y.indicator_id = i.id and y.date = '2011-12-31'::date
WHERE y.id IS NULL AND meta.clean_value(t."Clay", 'double precision')::double precision IS NOT NULL ;
INSERT INTO data.measurement(point_id, indicator_id, value, date, data_source_id)
SELECT x.id, i.id, meta.clean_value(t."CEC", 'double precision')::double precision, '2011-12-31'::date, 4 FROM t
LEFT JOIN data.point x ON x.point_key = t."Point_key"
left join data.indicator i on i.name_match = 'CEC' left join data.measurement y on y.point_id = x.id and y.indicator_id = i.id and y.date = '2011-12-31'::date
WHERE y.id IS NULL AND meta.clean_value(t."CEC", 'double precision')::double precision IS NOT NULL ;
END $function$
*/
}
/**
* @function import_danish_points
* @memberof data
* @description Import danish points
* @param {text} Params
* @param {text} Json
* @returns {void}
*/
function import_danish_points() {
/*
CREATE OR REPLACE FUNCTION data.import_danish_points("Params" text, "Json" text)
RETURNS void
LANGUAGE plpgsql
AS $function$
BEGIN
DROP TABLE IF EXISTS t;
CREATE TEMP TABLE t AS
SELECT * FROM json_to_recordset("Json"::json) AS J(
"id" varchar);
WITH x AS (SELECT DISTINCT t."id" FROM t)
INSERT INTO data.point(point_key, site_id)
SELECT meta.clean_value(x."id", 'varchar')::varchar, 6 FROM x
LEFT JOIN data.point point ON point.point_key= x."id"
WHERE point.id IS NULL;
END $function$
*/
}
/**
* @function import_danish_spectra
* @memberof data
* @description Import danish spectra
* @param {text} Params
* @param {text} Json
* @returns {void}
*/
function import_danish_spectra() {
/*
CREATE OR REPLACE FUNCTION data.import_danish_spectra("Params" text, "Json" text)
RETURNS void
LANGUAGE plpgsql
AS $function$
BEGIN
DROP TABLE IF EXISTS q;
CREATE TEMP TABLE q AS
SELECT * FROM json_to_recordset("Json"::json) AS J("reflectances" varchar, "id" varchar);
DROP TABLE IF EXISTS t;
CREATE TEMP TABLE t AS
SELECT q.*, o.id::varchar observation_id FROM q
INNER JOIN data.point p ON p.point_key = q.id INNER JOIN data.sample s ON s.point_id = p.id INNER JOIN data.observation o ON o.sample_id = s.id;
WITH x AS (SELECT DISTINCT t."reflectances", t."observation_id" FROM t)
INSERT INTO data.spectra_scan(signal_mean, observation_id)
SELECT meta.clean_value(x."reflectances", 'real[]')::real[], meta.clean_value(x."observation_id", 'int')::int FROM x
LEFT JOIN data.spectra_scan spectra_scan ON spectra_scan.observation_id= x."observation_id"::int
WHERE spectra_scan.id IS NULL;
END $function$
*/
}
/**
* @function import_lucas2009
* @memberof data
* @description Import lucas2009
* @param {text} jsonCV
* @param {text} jsonData
* @returns {void}
*/
function import_lucas2009() {
/*
CREATE OR REPLACE FUNCTION data.import_lucas2009("jsonCV" text, "jsonData" text)
RETURNS void
LANGUAGE plpgsql
AS $function$
BEGIN
DROP TABLE IF EXISTS t;
CREATE TEMP TABLE t AS
SELECT * FROM json_to_recordset("jsonData"::json) AS J(
"pH_in_CaCl2" varchar, "POINT_ID" varchar, "CaCO3" varchar, "CEC" varchar, "OC" varchar, "pH_in_H2O" varchar, "GPS_LONG" varchar, "GPS_LAT" varchar, "P" varchar, "N" varchar, "K" varchar, "coarse" varchar, "clay" varchar, "silt" varchar, "sand" varchar, "Notes" varchar, "sample_ID" varchar);
WITH x AS (SELECT DISTINCT t."POINT_ID", t."GPS_LONG", t."GPS_LAT", t."Notes", t."sample_ID" FROM t)
INSERT INTO data.point(point_key, lon, lat, notes, sample)
SELECT meta.clean_value(x."POINT_ID", 'varchar')::varchar, meta.clean_value(x."GPS_LONG", 'float8')::float8, meta.clean_value(x."GPS_LAT", 'float8')::float8, meta.clean_value(x."Notes", 'varchar')::varchar, meta.clean_value(x."sample_ID", 'int')::int FROM x
LEFT JOIN data.point point ON point.point_key= x."POINT_ID"
WHERE point.id IS NULL;
INSERT INTO data.measurement(point_id, indicator_id, value, date)
SELECT x.id, i.id, meta.clean_value(t."pH_in_CaCl2", 'float')::float, '2009-01-01'::date FROM t
LEFT JOIN data.point x ON x.point_key = t."POINT_ID"
left join data.indicator i on i.name_match = 'pH (CaCl2)' left join data.measurement y on y.point_id = x.id and y.indicator_id = i.id and y.date = '2009-01-01'::date
WHERE y.id IS NULL AND meta.clean_value(t."pH_in_CaCl2", 'float')::float IS NOT NULL ;
INSERT INTO data.measurement(point_id, indicator_id, value, date)
SELECT x.id, i.id, meta.clean_value(t."CaCO3", 'float')::float, '2009-01-01'::date FROM t
LEFT JOIN data.point x ON x.point_key = t."POINT_ID"
left join data.indicator i on i.name_match = 'CaCO3' left join data.measurement y on y.point_id = x.id and y.indicator_id = i.id and y.date = '2009-01-01'::date
WHERE y.id IS NULL AND meta.clean_value(t."CaCO3", 'float')::float IS NOT NULL ;
INSERT INTO data.measurement(point_id, indicator_id, value, date)
SELECT x.id, i.id, meta.clean_value(t."CEC", 'float')::float, '2019-01-01'::date FROM t
LEFT JOIN data.point x ON x.point_key = t."POINT_ID"
left join data.indicator i on i.name_match = 'CEC' left join data.measurement y on y.point_id = x.id and y.indicator_id = i.id and y.date = '2009-01-01'::date
WHERE y.id IS NULL AND meta.clean_value(t."CEC", 'float')::float IS NOT NULL ;
INSERT INTO data.measurement(point_id, indicator_id, value, date)
SELECT x.id, i.id, meta.clean_value(t."OC", 'float')::float, '2009-01-01'::date FROM t
LEFT JOIN data.point x ON x.point_key = t."POINT_ID"
left join data.indicator i on i.name = 'OC' left join data.measurement y on y.point_id = x.id and y.indicator_id = i.id and y.date = '2009-01-01'::date
WHERE y.id IS NULL AND meta.clean_value(t."OC", 'float')::float IS NOT NULL ;
INSERT INTO data.measurement(point_id, indicator_id, value, date)
SELECT x.id, i.id, meta.clean_value(t."pH_in_H2O", 'float')::float, '2009-01-01'::date FROM t
LEFT JOIN data.point x ON x.point_key = t."POINT_ID"
left join data.indicator i on i.name_match = 'pH (H2O)' left join data.measurement y on y.point_id = x.id and y.indicator_id = i.id and y.date = '2009-01-01'::date
WHERE y.id IS NULL AND meta.clean_value(t."pH_in_H2O", 'float')::float IS NOT NULL ;
INSERT INTO data.measurement(point_id, indicator_id, value, date)
SELECT x.id, i.id, meta.clean_value(t."P", 'float')::float, '2009-01-01'::date FROM t
LEFT JOIN data.point x ON x.point_key = t."POINT_ID"
left join data.indicator i on i.name_match = 'P' left join data.measurement y on y.point_id = x.id and y.indicator_id = i.id and y.date = '2009-01-01'::date
WHERE y.id IS NULL AND meta.clean_value(t."P", 'float')::float IS NOT NULL ;
INSERT INTO data.measurement(point_id, indicator_id, value, date)
SELECT x.id, i.id, meta.clean_value(t."N", 'float')::float, '2009-01-01'::date FROM t
LEFT JOIN data.point x ON x.point_key = t."POINT_ID"
left join data.indicator i on i.name_match = 'N' left join data.measurement y on y.point_id = x.id and y.indicator_id = i.id and y.date = '2009-01-01'::date
WHERE y.id IS NULL AND meta.clean_value(t."N", 'float')::float IS NOT NULL ;
INSERT INTO data.measurement(point_id, indicator_id, value, date)
SELECT x.id, i.id, meta.clean_value(t."K", 'float')::float, '2009-01-01'::date FROM t
LEFT JOIN data.point x ON x.point_key = t."POINT_ID"
left join data.indicator i on i.name_match = 'K' left join data.measurement y on y.point_id = x.id and y.indicator_id = i.id and y.date = '2009-01-01'::date
WHERE y.id IS NULL AND meta.clean_value(t."K", 'float')::float IS NOT NULL ;
INSERT INTO data.measurement(point_id, indicator_id, value, date)
SELECT x.id, i.id, meta.clean_value(t."coarse", 'float')::float, '2009-01-01'::date FROM t
LEFT JOIN data.point x ON x.point_key = t."POINT_ID"
left join data.indicator i on i.name_match = 'Clay' left join data.measurement y on y.point_id = x.id and y.indicator_id = i.id and y.date = '2009-01-01'::date
WHERE y.id IS NULL AND meta.clean_value(t."coarse", 'float')::float IS NOT NULL ;
INSERT INTO data.measurement(point_id, indicator_id, value, date)
SELECT x.id, i.id, meta.clean_value(t."clay", 'float')::float, '2009-01-01'::date FROM t
LEFT JOIN data.point x ON x.point_key = t."POINT_ID"
left join data.indicator i on i.name_match = 'Coarse' left join data.measurement y on y.point_id = x.id and y.indicator_id = i.id and y.date = '2009-01-01'::date
WHERE y.id IS NULL AND meta.clean_value(t."clay", 'float')::float IS NOT NULL ;
INSERT INTO data.measurement(point_id, indicator_id, value, date)
SELECT x.id, i.id, meta.clean_value(t."silt", 'float')::float, '2009-01-01'::date FROM t
LEFT JOIN data.point x ON x.point_key = t."POINT_ID"
left join data.indicator i on i.name_match = 'Silt' left join data.measurement y on y.point_id = x.id and y.indicator_id = i.id and y.date = '2009-01-01'::date
WHERE y.id IS NULL AND meta.clean_value(t."silt", 'float')::float IS NOT NULL ;
INSERT INTO data.measurement(point_id, indicator_id, value, date)
SELECT x.id, i.id, meta.clean_value(t."sand", 'float')::float, '2009-01-01'::date FROM t
LEFT JOIN data.point x ON x.point_key = t."POINT_ID"
left join data.indicator i on i.name_match = 'Sand' left join data.measurement y on y.point_id = x.id and y.indicator_id = i.id and y.date = '2009-01-01'::date
WHERE y.id IS NULL AND meta.clean_value(t."sand", 'float')::float IS NOT NULL ;
END $function$
*/
}
/**
* @function import_lucas2015att
* @memberof data
* @description Import lucas2015att
* @param {text} jsonCV
* @param {text} jsonData
* @returns {void}
*/
function import_lucas2015att() {
/*
CREATE OR REPLACE FUNCTION data.import_lucas2015att("jsonCV" text, "jsonData" text)
RETURNS void
LANGUAGE plpgsql
AS $function$
BEGIN
DROP TABLE IF EXISTS t;
CREATE TEMP TABLE t AS
SELECT * FROM json_to_recordset("jsonData"::json) AS J(
"LC0_Desc" varchar, "Point_ID" varchar, "LC" varchar, "LU" varchar);
WITH x AS (SELECT DISTINCT t."LC" FROM t)
INSERT INTO data.lc_detail(code)
SELECT meta.clean_value(x."LC", 'varchar')::varchar FROM x
LEFT JOIN data.lc_detail lc_detail ON lc_detail.code= x."LC"
WHERE lc_detail.id IS NULL;
WITH x AS (SELECT DISTINCT t."LC0_Desc" FROM t)
INSERT INTO data.lc_main(name)
SELECT meta.clean_value(x."LC0_Desc", 'varchar')::varchar FROM x
LEFT JOIN data.lc_main lc_main ON lc_main.name= x."LC0_Desc"
WHERE lc_main.id IS NULL;
WITH x AS (SELECT DISTINCT t."LU" FROM t)
INSERT INTO data.lu_detail(code)
SELECT meta.clean_value(x."LU", 'varchar')::varchar FROM x
LEFT JOIN data.lu_detail lu_detail ON lu_detail.code= x."LU"
WHERE lu_detail.id IS NULL;
WITH x AS (SELECT DISTINCT t."LC0_Desc", t."Point_ID", t."LC", t."LU" FROM t)
INSERT INTO data.point_att(lc_main_id, point_id, lc_detail_id, lu_detail_id)
SELECT lc_main.id, point.id, lc_detail.id, lu_detail.id
FROM x
INNER JOIN data.point point ON point.point_key= x."Point_ID"
LEFT JOIN data.lc_main lc_main ON lc_main.name = x."LC0_Desc"
LEFT JOIN data.lc_detail lc_detail ON lc_detail.code = x."LC"
LEFT JOIN data.lu_detail lu_detail ON lu_detail.code = x."LU"
; --WHERE point.id IS NULL;
END $function$
*/
}
/**
* @function import_lucas2015pm
* @memberof data
* @description Import lucas2015pm
* @param {text} jsonCV
* @param {text} jsonData
* @returns {void}
*/
function import_lucas2015pm() {
/*
CREATE OR REPLACE FUNCTION data.import_lucas2015pm("jsonCV" text, "jsonData" text)
RETURNS void
LANGUAGE plpgsql
AS $function$
BEGIN
DROP TABLE IF EXISTS t;
CREATE TEMP TABLE t AS
SELECT * FROM json_to_recordset("jsonData"::json) AS J(
"Point_ID" varchar, "NUTS_2" varchar, "NUTS_0" varchar, "pH_CaCl2" varchar, "CaCO3" varchar, "pH_H2O" varchar, "NUTS_1" varchar, "NUTS_3" varchar, "N" varchar, "OC" varchar, "K" varchar, "EC" varchar, "P" varchar, "X" varchar, "Y" varchar);
WITH x AS (SELECT DISTINCT t."NUTS_0" FROM t)
INSERT INTO data.nuts_0(name)
SELECT meta.clean_value(x."NUTS_0", 'varchar')::varchar FROM x
LEFT JOIN data.nuts_0 nuts_0 ON nuts_0.name= x."NUTS_0"
WHERE nuts_0.id IS NULL;
WITH x AS (SELECT DISTINCT t."NUTS_1" FROM t)
INSERT INTO data.nuts_1(name)
SELECT meta.clean_value(x."NUTS_1", 'varchar')::varchar FROM x
LEFT JOIN data.nuts_1 nuts_1 ON nuts_1.name= x."NUTS_1"
WHERE nuts_1.id IS NULL;
WITH x AS (SELECT DISTINCT t."NUTS_2" FROM t)
INSERT INTO data.nuts_2(name)
SELECT meta.clean_value(x."NUTS_2", 'varchar')::varchar FROM x
LEFT JOIN data.nuts_2 nuts_2 ON nuts_2.name= x."NUTS_2"
WHERE nuts_2.id IS NULL;
WITH x AS (SELECT DISTINCT t."NUTS_3" FROM t)
INSERT INTO data.nuts_3(name)
SELECT meta.clean_value(x."NUTS_3", 'varchar')::varchar FROM x
LEFT JOIN data.nuts_3 nuts_3 ON nuts_3.name= x."NUTS_3"
WHERE nuts_3.id IS NULL;
WITH x AS (SELECT DISTINCT t."Point_ID", t."NUTS_2", t."NUTS_0", t."NUTS_1", t."NUTS_3", t."X", t."Y" FROM t)
INSERT INTO data.point(point_key, nuts_2_id, nuts_0_id, nuts_1_id, nuts_3_id, lon, lat)
SELECT meta.clean_value(x."Point_ID", 'varchar')::varchar, nuts_2.id, nuts_0.id, nuts_1.id, nuts_3.id, meta.clean_value(x."X", 'float8')::float8, meta.clean_value(x."Y", 'float8')::float8 FROM x
LEFT JOIN data.point point ON point.point_key= x."Point_ID"
LEFT JOIN data.nuts_2 nuts_2 ON nuts_2.name = x."NUTS_2"
LEFT JOIN data.nuts_0 nuts_0 ON nuts_0.name = x."NUTS_0"
LEFT JOIN data.nuts_1 nuts_1 ON nuts_1.name = x."NUTS_1"
LEFT JOIN data.nuts_3 nuts_3 ON nuts_3.name = x."NUTS_3"
WHERE point.id IS NULL;
INSERT INTO data.measurement(point_id, indicator_id, value, date)
SELECT x.id, i.id, meta.clean_value(t."pH_CaCl2", 'float')::float, '2015-01-01'::date FROM t
LEFT JOIN data.point x ON x.point_key = t."Point_ID"
left join data.indicator i on i.name_match = 'pH (CaCl2)' left join data.measurement y on y.point_id = x.id and y.indicator_id = i.id and y.date = '2015-01-01'::date
WHERE y.id IS NULL AND meta.clean_value(t."pH_CaCl2", 'float')::float IS NOT NULL ;
INSERT INTO data.measurement(point_id, indicator_id, value, date)
SELECT x.id, i.id, meta.clean_value(t."CaCO3", 'float')::float, '2015-01-01'::date FROM t
LEFT JOIN data.point x ON x.point_key = t."Point_ID"
left join data.indicator i on i.name_match = 'CaCO3' left join data.measurement y on y.point_id = x.id and y.indicator_id = i.id and y.date = '2015-01-01'::date
WHERE y.id IS NULL AND meta.clean_value(t."CaCO3", 'float')::float IS NOT NULL ;
INSERT INTO data.measurement(point_id, indicator_id, value, date)
SELECT x.id, i.id, meta.clean_value(t."pH_H2O", 'float')::float, '2015-01-01'::date FROM t
LEFT JOIN data.point x ON x.point_key = t."Point_ID"
left join data.indicator i on i.name_match = 'pH (H2O)' left join data.measurement y on y.point_id = x.id and y.indicator_id = i.id and y.date = '2015-01-01'::date
WHERE y.id IS NULL AND meta.clean_value(t."pH_H2O", 'float')::float IS NOT NULL ;
INSERT INTO data.measurement(point_id, indicator_id, value, date)
SELECT x.id, i.id, meta.clean_value(t."N", 'float')::float, '2015-01-01'::date FROM t
LEFT JOIN data.point x ON x.point_key = t."Point_ID"
left join data.indicator i on i.name_match = 'N' left join data.measurement y on y.point_id = x.id and y.indicator_id = i.id and y.date = '2015-01-01'::date
WHERE y.id IS NULL AND meta.clean_value(t."N", 'float')::float IS NOT NULL ;
INSERT INTO data.measurement(point_id, indicator_id, value, date)
SELECT x.id, i.id, meta.clean_value(t."OC", 'float')::float, '2015-01-01'::date FROM t
LEFT JOIN data.point x ON x.point_key = t."Point_ID"
left join data.indicator i on i.name = 'OC' left join data.measurement y on y.point_id = x.id and y.indicator_id = i.id and y.date = '2015-01-01'::date
WHERE y.id IS NULL AND meta.clean_value(t."OC", 'float')::float IS NOT NULL ;
INSERT INTO data.measurement(point_id, indicator_id, value, date)
SELECT x.id, i.id, meta.clean_value(t."K", 'float')::float, '2015-01-01'::date FROM t
LEFT JOIN data.point x ON x.point_key = t."Point_ID"
left join data.indicator i on i.name_match = 'K' left join data.measurement y on y.point_id = x.id and y.indicator_id = i.id and y.date = '2015-01-01'::date
WHERE y.id IS NULL AND meta.clean_value(t."K", 'float')::float IS NOT NULL ;
INSERT INTO data.measurement(point_id, indicator_id, value, date)
SELECT x.id, i.id, meta.clean_value(t."EC", 'float')::float, '2015-01-01'::date FROM t
LEFT JOIN data.point x ON x.point_key = t."Point_ID"
left join data.indicator i on i.name_match = 'EC' left join data.measurement y on y.point_id = x.id and y.indicator_id = i.id and y.date = '2015-01-01'::date
WHERE y.id IS NULL AND meta.clean_value(t."EC", 'float')::float IS NOT NULL ;
INSERT INTO data.measurement(point_id, indicator_id, value, date)
SELECT x.id, i.id, meta.clean_value(t."P", 'float')::float, '2015-01-01'::date FROM t
LEFT JOIN data.point x ON x.point_key = t."Point_ID"
left join data.indicator i on i.name_match = 'P' left join data.measurement y on y.point_id = x.id and y.indicator_id = i.id and y.date = '2015-01-01'::date
WHERE y.id IS NULL AND meta.clean_value(t."P", 'float')::float IS NOT NULL ;
END $function$
*/
}
/**
* @function import_shdc
* @memberof data
* @description Import shdc
* @param {text} Params
* @param {text} Json
* @returns {void}
*/
function import_shdc() {
/*
CREATE OR REPLACE FUNCTION data.import_shdc("Params" text, "Json" text)
RETURNS void
LANGUAGE plpgsql
AS $function$
BEGIN
DROP TABLE IF EXISTS q;
CREATE TEMP TABLE q AS
SELECT * FROM json_to_recordset("Json"::json) AS J("Soil property" varchar, "File name" varchar, "Scale factor" varchar, "NoData Values" varchar, "Details" varchar, "qml" varchar, "sld" varchar, "Unit of Measurement" varchar);
DROP TABLE IF EXISTS t;
CREATE TEMP TABLE t AS
SELECT q.* FROM q
;
WITH x AS (SELECT DISTINCT t."Unit of Measurement" FROM t)
INSERT INTO catalog.unit(name)
SELECT meta.clean_value(x."Unit of Measurement", 'varchar')::varchar FROM x
LEFT JOIN catalog.unit unit ON unit.name_match = x."Unit of Measurement"::varchar
WHERE unit.id IS NULL;
WITH x AS (SELECT DISTINCT t."Soil property", t."File name", t."Scale factor", t."NoData Values", t."Details", t."qml", t."sld", t."Unit of Measurement" FROM t)
INSERT INTO data.shdc(property, file_name, scale_factor, no_data, details, qml, sld, unit_id)
SELECT meta.clean_value(x."Soil property", 'varchar')::varchar, meta.clean_value(x."File name", 'varchar')::varchar, meta.clean_value(x."Scale factor", 'float4')::float4, meta.clean_value(x."NoData Values", 'int')::int, meta.clean_value(x."Details", 'varchar')::varchar, meta.clean_value(x."qml", 'varchar')::varchar, meta.clean_value(x."sld", 'varchar')::varchar, unit.id FROM x
LEFT JOIN data.shdc shdc ON shdc.property= x."Soil property"::varchar
LEFT JOIN catalog.unit unit ON unit.name_match = x."Unit of Measurement"::varchar
WHERE shdc.id IS NULL;
END $function$
*/
}
/**
* @function import_shdc_files
* @memberof data
* @description Import shdc files
* @param {text} Params
* @param {text} Json
* @returns {void}
*/
function import_shdc_files() {
/*
CREATE OR REPLACE FUNCTION data.import_shdc_files("Params" text, "Json" text)
RETURNS void
LANGUAGE plpgsql
AS $function$
BEGIN
DROP TABLE IF EXISTS q;
CREATE TEMP TABLE q AS
SELECT * FROM json_to_recordset("Json"::json) AS J("File Name" varchar, "Property" varchar, "Depth" varchar, "Temporal Coverage (start)" varchar, "Temporal Coverage (end)" varchar, "Value" varchar, "Wasabi links" varchar, "Description" varchar);
DROP TABLE IF EXISTS t;
CREATE TEMP TABLE t AS
SELECT q.* FROM q
;
WITH x AS (SELECT DISTINCT t."Property" FROM t)
INSERT INTO data.shdc(property)
SELECT meta.clean_value(x."Property", 'varchar')::varchar FROM x
LEFT JOIN data.shdc shdc ON shdc.property= x."Property"::varchar
WHERE shdc.id IS NULL;
WITH x AS (SELECT DISTINCT t."Depth" FROM t)
INSERT INTO data.depth(name)
SELECT meta.clean_value(x."Depth", 'varchar')::varchar FROM x
LEFT JOIN data.depth depth ON depth.name= x."Depth"::varchar
WHERE depth.id IS NULL;
WITH x AS (SELECT DISTINCT t."File Name", t."Property", t."Depth", t."Temporal Coverage (start)", t."Temporal Coverage (end)", t."Value", t."Wasabi links", t."Description" FROM t)
INSERT INTO data.shdc_file(file_name, shdc_id, depth_id, temporal_coverage_start, temporal_coverage_end, value, wasabi_link, description)
SELECT meta.clean_value(x."File Name", 'varchar')::varchar, shdc.id, depth.id, meta.clean_value(x."Temporal Coverage (start)", 'varchar')::varchar, meta.clean_value(x."Temporal Coverage (end)", 'varchar')::varchar, meta.clean_value(x."Value", 'varchar')::varchar, meta.clean_value(x."Wasabi links", 'varchar')::varchar, meta.clean_value(x."Description", 'text')::text FROM x
LEFT JOIN data.shdc_file shdc_file ON shdc_file.file_name= x."File Name"::varchar
LEFT JOIN data.shdc shdc ON shdc.property = x."Property"::varchar
LEFT JOIN data.depth depth ON depth.name = x."Depth"::varchar
WHERE shdc_file.id IS NULL;
END $function$
*/
}
/**
* @function import_shdc_soil_type
* @memberof data
* @description Import shdc soil type
* @param {text} Params
* @param {text} Json
* @returns {void}
*/
function import_shdc_soil_type() {
/*
CREATE OR REPLACE FUNCTION data.import_shdc_soil_type("Params" text, "Json" text)
RETURNS void
LANGUAGE plpgsql
AS $function$
BEGIN
DROP TABLE IF EXISTS q;
CREATE TEMP TABLE q AS
SELECT * FROM json_to_recordset("Json"::json) AS J("code" varchar, "wrb22_code" varchar, "formatted_code" varchar, "number_of_occurrances_training_points" varchar);
DROP TABLE IF EXISTS t;
CREATE TEMP TABLE t AS
SELECT q.* FROM q
;
WITH x AS (SELECT DISTINCT t."code", t."wrb22_code", t."formatted_code", t."number_of_occurrances_training_points" FROM t)
INSERT INTO data.shdc_soil_type(code, wrb_22_code, formatted_code, number_of_occurrances_training_points)
SELECT meta.clean_value(x."code", 'int')::int, meta.clean_value(x."wrb22_code", 'varchar')::varchar, meta.clean_value(x."formatted_code", 'varchar')::varchar, meta.clean_value(x."number_of_occurrances_training_points", 'int')::int FROM x
LEFT JOIN data.shdc_soil_type shdc_soil_type ON shdc_soil_type.code= meta.clean_value( x."code", 'int')::int
WHERE shdc_soil_type.id IS NULL;
END $function$
*/
}
/**
* @function import_spain
* @memberof data
* @description Import spain
* @param {text} jsonCV
* @param {text} jsonData
* @returns {void}
*/
function import_spain() {
/*
CREATE OR REPLACE FUNCTION data.import_spain("jsonCV" text, "jsonData" text)
RETURNS void
LANGUAGE plpgsql
AS $function$
BEGIN
DROP TABLE IF EXISTS t;
CREATE TEMP TABLE t AS
SELECT * FROM json_to_recordset("jsonData"::json) AS J(
"Year" varchar, "date" varchar, "point_key" varchar, "depth" varchar, "Elevation (m)" varchar, "Coord X" varchar, "Coord Y" varchar, "Springtime grass production (kg ha-1)" varchar, "Topsoil carbon storage (t C ha-1)" varchar, "Carbonates (g/kg)" varchar, "Organic carbon (g/kg)" varchar, "Silt (%)" varchar, "Clay (%)" varchar);
WITH x AS (SELECT DISTINCT t."depth" FROM t)
INSERT INTO data.depth(name)
SELECT meta.clean_value(x."depth", 'varchar')::varchar FROM x
LEFT JOIN data.depth depth ON depth.name= x."depth"
WHERE depth.id IS NULL;
WITH x AS (SELECT DISTINCT t."point_key", t."Elevation (m)", t."Coord X", t."Coord Y" FROM t)
INSERT INTO data.point(point_key, elev, lon, lat, data_source_id)
SELECT meta.clean_value(x."point_key", 'varchar')::varchar, meta.clean_value(x."Elevation (m)", 'float')::float, meta.clean_value(x."Coord X", 'double precision')::double precision, meta.clean_value(x."Coord Y", 'double precision')::double precision, 6 FROM x
LEFT JOIN data.point point ON point.point_key= x."point_key"
WHERE point.id IS NULL;
INSERT INTO data.measurement(point_id, indicator_id, depth_id, value, date, data_source_id)
SELECT x.id, i.id, d.id, meta.clean_value(t."Springtime grass production (kg ha-1)", 'double precision')::double precision, meta.clean_value(t.date, 'date')::date, 6 FROM t
LEFT JOIN data.point x ON x.point_key = t."point_key"
left join data.indicator i on i.name_match = 'Springtime grass production' left join data.measurement y on y.point_id = x.id and y.indicator_id = i.id and y.date = meta.clean_value(t.date, 'date')::date left join data.depth d on d.name = t.depth
WHERE y.id IS NULL AND meta.clean_value(t."Springtime grass production (kg ha-1)", 'double precision')::double precision IS NOT NULL ;
INSERT INTO data.measurement(point_id, indicator_id, depth_id, value, date, data_source_id)
SELECT x.id, i.id, d.id, meta.clean_value(t."Topsoil carbon storage (t C ha-1)", 'double precision')::double precision, meta.clean_value(t.date, 'date')::date, 6 FROM t
LEFT JOIN data.point x ON x.point_key = t."point_key"
left join data.indicator i on i.name_match = 'Topsoil carbon storage' left join data.measurement y on y.point_id = x.id and y.indicator_id = i.id and y.date = meta.clean_value(t.date, 'date')::date left join data.depth d on d.name = t.depth
WHERE y.id IS NULL AND meta.clean_value(t."Topsoil carbon storage (t C ha-1)", 'double precision')::double precision IS NOT NULL ;
INSERT INTO data.measurement(point_id, indicator_id, depth_id, value, date, data_source_id)
SELECT x.id, i.id, d.id, meta.clean_value(t."Carbonates (g/kg)", 'double precision')::double precision, meta.clean_value(t.date, 'date')::date, 6 FROM t
LEFT JOIN data.point x ON x.point_key = t."point_key"
left join data.indicator i on i.name_match = 'CaCO3' left join data.measurement y on y.point_id = x.id and y.indicator_id = i.id and y.date = meta.clean_value(t.date, 'date')::date left join data.depth d on d.name = t.depth
WHERE y.id IS NULL AND meta.clean_value(t."Carbonates (g/kg)", 'double precision')::double precision IS NOT NULL ;
INSERT INTO data.measurement(point_id, indicator_id, depth_id, value, date, data_source_id)
SELECT x.id, i.id, d.id, meta.clean_value(t."Organic carbon (g/kg)", 'double precision')::double precision, meta.clean_value(t.date, 'date')::date, 6 FROM t
LEFT JOIN data.point x ON x.point_key = t."point_key"
left join data.indicator i on i.name_match = 'OC' left join data.measurement y on y.point_id = x.id and y.indicator_id = i.id and y.date = meta.clean_value(t.date, 'date')::date left join data.depth d on d.name = t.depth
WHERE y.id IS NULL AND meta.clean_value(t."Organic carbon (g/kg)", 'double precision')::double precision IS NOT NULL ;
INSERT INTO data.measurement(point_id, indicator_id, depth_id, value, date, data_source_id)
SELECT x.id, i.id, d.id, meta.clean_value(t."Silt (%)", 'double precision')::double precision, meta.clean_value(t.date, 'date')::date, 6 FROM t
LEFT JOIN data.point x ON x.point_key = t."point_key"
left join data.indicator i on i.name_match = 'Silt' left join data.measurement y on y.point_id = x.id and y.indicator_id = i.id and y.date = meta.clean_value(t.date, 'date')::date left join data.depth d on d.name = t.depth
WHERE y.id IS NULL AND meta.clean_value(t."Silt (%)", 'double precision')::double precision IS NOT NULL ;
INSERT INTO data.measurement(point_id, indicator_id, depth_id, value, date, data_source_id)
SELECT x.id, i.id, d.id, meta.clean_value(t."Clay (%)", 'double precision')::double precision, meta.clean_value(t.date, 'date')::date, 6 FROM t
LEFT JOIN data.point x ON x.point_key = t."point_key"
left join data.indicator i on i.name_match = 'Clay' left join data.measurement y on y.point_id = x.id and y.indicator_id = i.id and y.date = meta.clean_value(t.date, 'date')::date left join data.depth d on d.name = t.depth
WHERE y.id IS NULL AND meta.clean_value(t."Clay (%)", 'double precision')::double precision IS NOT NULL ;
END $function$
*/
}
/**
* @function import_spectra
* @memberof data
* @description Import spectra
* @param {text} Params
* @param {text} Json
* @returns {void}
*/
function import_spectra() {
/*
CREATE OR REPLACE FUNCTION data.import_spectra("Params" text, "Json" text)
RETURNS void
LANGUAGE plpgsql
AS $function$
BEGIN
DROP TABLE IF EXISTS t;
CREATE TEMP TABLE t AS
SELECT * FROM json_to_recordset("Json"::json) AS t(id int, wavelengths int[], values float4[]);
INSERT INTO data.spectrum AS s (point_id, data_source_id, date, wavelengths, values)
SELECT p.id, (("Params"::json)->>'data_source_id')::int, (("Params"::json)->>'date')::date, t.wavelengths, t.values
FROM t
INNER JOIN data.point AS p ON p.sample = t.id
ON CONFLICT(point_id, data_source_id, date)
DO UPDATE SET wavelengths = EXCLUDED.wavelengths, values = EXCLUDED.values;
END $function$
*/
}
/**
* @function import_taxa_heterogeneity_function
* @memberof data
* @description Import taxa heterogeneity function
* @param {text} Params
* @param {text} Json
* @returns {void}
*/
function import_taxa_heterogeneity_function() {
/*
CREATE OR REPLACE FUNCTION data.import_taxa_heterogeneity_function("Params" text, "Json" text)
RETURNS void
LANGUAGE plpgsql
AS $function$
BEGIN
DROP TABLE IF EXISTS q;
CREATE TEMP TABLE q AS
SELECT * FROM json_to_recordset("Json"::json) AS J("function" varchar, "quantity" varchar, "function" varchar);
DROP TABLE IF EXISTS t;
CREATE TEMP TABLE t AS
SELECT q.* FROM q
;
WITH x AS (SELECT DISTINCT t."function" FROM t)
INSERT INTO data.taxa_function(name)
SELECT meta.clean_value(x."function", 'varchar')::varchar FROM x
LEFT JOIN data.taxa_function taxa_function ON taxa_function.name= x."function"::varchar
WHERE taxa_function.id IS NULL;
WITH x AS (SELECT DISTINCT t."function", t."quantity", t."function" FROM t)
INSERT INTO data.taxa_heterogeneity_function(taxa_function_id, quantity, taxa_function_id)
SELECT taxa_function.id, meta.clean_value(x."quantity", 'double precision')::double precision, meta.clean_value(x."function", 'integer')::integer FROM x
LEFT JOIN data.taxa_heterogeneity_function taxa_heterogeneity_function ON taxa_heterogeneity_function.taxa_function_id= x."function"::integer
LEFT JOIN data.taxa_function taxa_function ON taxa_function.name = x."function"::varchar
WHERE taxa_heterogeneity_function.id IS NULL;
END $function$
*/
}
/**
* @function import_temp
* @memberof data
* @description Import temp
* @param {text} jsonCV
* @param {text} jsonData
* @returns {void}
*/
function import_temp() {
/*
CREATE OR REPLACE FUNCTION data.import_temp("jsonCV" text, "jsonData" text)
RETURNS void
LANGUAGE plpgsql
AS $function$
BEGIN
DROP TABLE IF EXISTS t;
CREATE TEMP TABLE t AS
SELECT * FROM json_to_recordset("jsonData"::json) AS J(
"Point_ID" varchar, "Revisited_point" varchar, "Coarse" varchar, "Clay" varchar, "Sand" varchar, "Silt" varchar, "pH_CaCl2" varchar, "pH_H2O" varchar, "EC" varchar, "OC" varchar, "CaCO3" varchar, "P" varchar, "N" varchar, "K" varchar, "Elevation" varchar, "LC1" varchar, "LU1" varchar, "Soil_Stones" varchar, "NUTS_0" varchar, "NUTS_1" varchar, "NUTS_2" varchar, "NUTS_3" varchar, "LC1_Desc" varchar, "LU1_Desc" varchar);
WITH x AS (SELECT DISTINCT t."Point_ID", t."Revisited_point", t."Coarse", t."Clay", t."Sand", t."Silt", t."pH_CaCl2", t."pH_H2O", t."EC", t."OC", t."CaCO3", t."P", t."N", t."K", t."Elevation", t."LC1", t."LU1", t."Soil_Stones", t."NUTS_0", t."NUTS_1", t."NUTS_2", t."NUTS_3", t."LC1_Desc", t."LU1_Desc" FROM t)
INSERT INTO data.temp(point_id, revisited_point, coarse, clay, sand, silt, p_h_ca_cl_2, p_h_h2o, ec, oc, ca_co3, p, n, k, elevation, lc1, lu1, soil_stones, nuts_0, nuts_1, nuts_2, nuts_3, lc1_desc, lu1_desc)
SELECT meta.clean_value(x."Point_ID", 'varchar')::varchar, meta.clean_value(x."Revisited_point", 'varchar')::varchar, meta.clean_value(x."Coarse", 'varchar')::varchar, meta.clean_value(x."Clay", 'varchar')::varchar, meta.clean_value(x."Sand", 'varchar')::varchar, meta.clean_value(x."Silt", 'varchar')::varchar, meta.clean_value(x."pH_CaCl2", 'varchar')::varchar, meta.clean_value(x."pH_H2O", 'varchar')::varchar, meta.clean_value(x."EC", 'varchar')::varchar, meta.clean_value(x."OC", 'varchar')::varchar, meta.clean_value(x."CaCO3", 'varchar')::varchar, meta.clean_value(x."P", 'varchar')::varchar, meta.clean_value(x."N", 'varchar')::varchar, meta.clean_value(x."K", 'varchar')::varchar, meta.clean_value(x."Elevation", 'varchar')::varchar, meta.clean_value(x."LC1", 'varchar')::varchar, meta.clean_value(x."LU1", 'varchar')::varchar, meta.clean_value(x."Soil_Stones", 'varchar')::varchar, meta.clean_value(x."NUTS_0", 'varchar')::varchar, meta.clean_value(x."NUTS_1", 'varchar')::varchar, meta.clean_value(x."NUTS_2", 'varchar')::varchar, meta.clean_value(x."NUTS_3", 'varchar')::varchar, meta.clean_value(x."LC1_Desc", 'varchar')::varchar, meta.clean_value(x."LU1_Desc", 'varchar')::varchar FROM x
LEFT JOIN data.temp temp ON temp.point_id= x."Point_ID"
WHERE temp.id IS NULL;
END $function$
*/
}
/**
* @function save_image
* @memberof data
* @description Save image
* @param {integer} Id
* @param {integer} SimpleObservationId
* @param {text} Name
* @param {text} FileName
* @param {text} Extension
* @param {text} MimeType
* @param {integer} Compass
* @param {double_precision} Lat
* @param {double_precision} Lon
* @returns {integer}
*/
function save_image() {
/*
CREATE OR REPLACE FUNCTION data.save_image("Id" integer, "SimpleObservationId" integer, "Name" text, "FileName" text, "Extension" text, "MimeType" text, "Compass" integer, "Lat" double precision, "Lon" double precision)
RETURNS integer
LANGUAGE plpgsql
AS $function$
begin
if "Id" is null then
insert into data.image (simple_observation_id, name, file_name, extension, mime_type, compass, lat, lon)
values ("SimpleObservationId", "Name", "FileName", "Extension", "MimeType", "Compass", "Lat", "Lon")
returning id into "Id";
else
update data.image
set simple_observation_id = "SimpleObservationId",
name = "Name",
file_name = "FileName",
extension = "Extension",
mime_type = "MimeType",
compass = "Compass",
lat = "Lat",
lon = "Lon"
where id = "Id";
end if;
return "Id";
end $function$
*/
}
/**
* @function save_sampling_log_image_metadata
* @memberof data
* @description Save sampling log image metadata
* @param {integer} Id
* @param {text} Extension
* @param {text} MimeType
* @returns {integer}
*/
function save_sampling_log_image_metadata() {
/*
CREATE OR REPLACE FUNCTION data.save_sampling_log_image_metadata("Id" integer, "Extension" text, "MimeType" text)
RETURNS integer
LANGUAGE plpgsql
AS $function$
BEGIN
UPDATE data.sampling_log_image
SET extension = "Extension",
mime_type = "MimeType"
WHERE id = "Id";
RETURN "Id";
END $function$
*/
}
/**
* @function set_color_map
* @memberof data
* @description Set color map associated with an asset
* @param {integer} Id
* @param {text} ColorMap
* @returns {void}
*/
function set_color_map() {
/*
CREATE OR REPLACE FUNCTION data.set_color_map("Id" integer, "ColorMap" text)
RETURNS void
LANGUAGE plpgsql
AS $function$
BEGIN
UPDATE data.asset SET color_map = "ColorMap" WHERE id = "Id";
END;
$function$
*/
}
/**
* @function set_color_map_from_sld
* @memberof data
* @description Set color map from sld
* @param {integer} Id
* @param {text} Sld
* @returns {void}
*/
function set_color_map_from_sld() {
/*
CREATE OR REPLACE FUNCTION data.set_color_map_from_sld("Id" integer, "Sld" text)
RETURNS void
LANGUAGE plpgsql
AS $function$
DECLARE
sld_xml TEXT;
color_map_entries XML[];
entry XML;
result TEXT := '[ "interpolate", [ "linear" ], [ "band", 1 ], 0, [255, 255, 255, 0],';
a XML[];
quantity FLOAT;
hex_color TEXT;
r INT;
g INT;
b INT;
alpha FLOAT := 1.0;
BEGIN
IF "Sld" IS NULL OR "Sld" = '' THEN
RETURN;
END IF;
-- Fetch XML from URL
SELECT content INTO sld_xml FROM http_get("Sld");
-- Extract all <sld:ColorMapEntry> elements
SELECT ARRAY(
SELECT unnest(xpath('//sld:ColorMapEntry', sld_xml::XML,
ARRAY[ARRAY['sld', 'http://www.opengis.net/sld']]
))
) INTO color_map_entries;
-- Loop through each <sld:ColorMapEntry> and extract values
FOREACH entry IN ARRAY color_map_entries LOOP
RAISE NOTICE 'Entry %', entry;
-- Extract quantity
SELECT xpath('//@quantity', entry) INTO a;
quantity := a[1]::TEXT::FLOAT;
-- Extract color (hex format)
SELECT xpath('//@color', entry) INTO a;
hex_color := a[1]::TEXT;
-- Convert hex color to RGB
r := ('x' || substring(hex_color FROM 2 FOR 2))::bit(8)::int;
g := ('x' || substring(hex_color FROM 4 FOR 2))::bit(8)::int;
b := ('x' || substring(hex_color FROM 6 FOR 2))::bit(8)::int;
-- Append to result string
result := result || format('%s, [ %s, %s, %s, %s ], ', quantity, r, g, b, alpha);
END LOOP;
-- Remove trailing comma and close JSON array
-- result := trim(trailing ', ' FROM result) || ']';
result := result || (2*quantity)::varchar || ', [0, 0, 0, 1]]';
UPDATE data.shdc SET color_map = result WHERE id = "Id";
END;
$function$
*/
}
/**
* @function update_custom_geometry
* @memberof data
* @description set custom geometry
* @param {json} json object containing custom geometry in 'Feature'
* @returns {void}
*/
function set_custom_geometry() {
/*
CREATE OR REPLACE FUNCTION data.set_custom_geometry("Json" text)
RETURNS json
LANGUAGE plpgsql
AS $function$
DECLARE v_RowCountInt INT;
v_id INT;
j json;
feature json;
v_geometry json;
properties json;
image_id INT;
BEGIN
j := "Json"::json;
feature := (j->>'feature')::json;
v_geometry := (feature->>'geometry')::json;
v_id := (j->>'key')::int;
properties := feature->>'properties';
if properties is not null then
image_id := (properties->>'image_id')::int;
end if;
IF image_id IS NOT NULL THEN
UPDATE data.image SET lat = (v_geometry->'coordinates'->>1)::double precision, lon = (v_geometry->'coordinates'->>0)::double precision
WHERE id = image_id;
ELSE
UPDATE data.custom_geometry
SET geometry = st_geomfromgeojson(v_geometry)
WHERE id = v_id;
GET DIAGNOSTICS v_RowCountInt = ROW_COUNT;
IF v_RowCountInt = 0 THEN
INSERT INTO data.custom_geometry (person_id, geometry)
VALUES (auth.get_context_person_id(), st_geomfromgeojson(v_geometry))
RETURNING id INTO v_id;
END IF;
END IF;
RETURN json_build_object('key', v_id);
END
$function$
*/
}
/**
* @function set_shape_geometry
* @memberof data
* @description Set shape geometry
* @param {integer} Id - site id
* @param {integer} Srid
* @param {text} Properties
* @param {text} Geometry
* @returns {void}
*/
function set_geometry() {
/*
CREATE OR REPLACE FUNCTION data.set_geometry("Id" integer, "Srid" integer, "GeometryTypeId" integer, "Properties" text, "Geometry" text)
RETURNS void
LANGUAGE plpgsql
AS $function$
DECLARE p json;
DECLARE parents VARCHAR;
BEGIN
INSERT INTO data.geometry (
geometry_type_id,
parent_id,
properties,
geom)
VALUES (
"GeometryTypeId",
"Id",
"Properties"::json,
st_transform(st_multi(st_setsrid(st_geomfromgeojson("Geometry"), "Srid")), 3035)
);
RETURN;
END$function$
*/
}
/**
* @function set_lon_lat_nuts_for_points
* @memberof data
* @description Set lon lat nuts for points in data.point which have no lon and lat and nuts
* @param {integer} srid
* @returns {void}
*/
function set_lon_lat_nuts_for_points() {
/*
CREATE OR REPLACE FUNCTION data.set_lon_lat_nuts_for_points(srid integer)
RETURNS void
LANGUAGE plpgsql
AS $function$
BEGIN
UPDATE data.point p
SET lon = ST_X(ST_Transform(ST_SetSRID(ST_MakePoint(x, y), srid), 4326)),
lat = ST_Y(ST_Transform(ST_SetSRID(ST_MakePoint(x, y), srid), 4326))
where lat is null and lon is null;
--CREATE INDEX point_geom_index ON data.point
--USING gist (st_transform(st_setsrid(st_makepoint(lon, lat), 4326), 3035) public.gist_geometry_ops_2d);
UPDATE data.point p SET l3_id =
(SELECT id FROM general.nuts n
WHERE n.levl_code = 3 AND
ST_Contains(n.geom, ST_Transform(ST_SetSRID(ST_MakePoint(p.lon, p.lat), 4326), 3035)))
WHERE l3_id IS NULL AND lat IS NOT NULL AND lon IS NOT NULL;
-- DROP INDEX data.point_geom_index;
END $function$
*/
}
/**
* @function update_point
* @memberof data
* @description Update point by id with new geometry
* @param {integer} Id
* @param {text} Feature
* @returns {void}
*/
function set_point() {
/*
CREATE OR REPLACE FUNCTION data.set_point("Json" text)
RETURNS json
LANGUAGE plpgsql
AS $function$
DECLARE
j json;
feature json;
v_RowCountInt INT;
v_geometry geometry;
v_lon double precision;
v_lat double precision;
v_id integer;
v_site_id integer;
properties json;
BEGIN
j := "Json"::json;
feature := (j->>'feature')::json;
properties := (feature->>'properties')::json;
v_geometry := st_geomfromgeojson((feature->>'geometry')::json);
v_lon := st_x(v_geometry);
v_lat := st_y(v_geometry);
v_id := (properties->>'key')::integer;
v_site_id := (j->>'site_id')::integer;
UPDATE data.point
SET lon = v_lon, lat = v_lat
WHERE id = v_id;
GET DIAGNOSTICS v_RowCountInt = ROW_COUNT;
IF v_RowCountInt = 0 THEN
INSERT INTO data.point (lon, lat, site_id) VALUES (v_lon, v_lat, v_site_id)
RETURNING id INTO v_id;
END IF;
RETURN json_build_object('key', v_id, 'site_id', v_site_id);
END
$function$
*/
}
/**
* @function set_point_geom
* @memberof data
* @description Set point geom
* @returns {trigger}
*/
function set_point_geom() {
/*
CREATE OR REPLACE FUNCTION data.set_point_geom()
RETURNS trigger
LANGUAGE plpgsql
AS $function$
BEGIN
NEW.geom = st_transform(st_setsrid(st_point(NEW.lon, NEW.lat), 4326), 3035);
RETURN NEW;
END;
$function$
*/
}
/**
* @function update_point_lat_lon
* @memberof data
* @description Update point by Pointkey with Lat and Lon
* @param {varchar} Pointkey
* @param {double} Lat
* @param {double} Lon
* @param {int} SiteId
* @returns {void}
*/
function set_point_lat_lon() {
/*
CREATE OR REPLACE FUNCTION data.set_point_lat_lon("PointKey" character varying, "Lat" double precision, "Lon" double precision, "SiteId" integer)
RETURNS void
LANGUAGE plpgsql
AS $function$
DECLARE v_RowCountInt int;
BEGIN
UPDATE data.point
SET lon = "Lon", lat = "Lat", site_id = "SiteId"
WHERE point_key = "PointKey";
GET DIAGNOSTICS v_RowCountInt = ROW_COUNT;
IF v_RowCountInt = 0 THEN
INSERT INTO data.point (point_key, lon, lat, site_id) VALUES ("PointKey", "Lon", "Lat", "SiteId");
END IF;
RETURN;
END
$function$
*/
}
/**
* @function set_single_geometry
* @memberof data
* @description Set single geometry
* @param {text} Json
* @returns {json}
*/
function set_single_geometry() {
/*
CREATE OR REPLACE FUNCTION data.set_single_geometry("Json" text)
RETURNS json
LANGUAGE plpgsql
AS $function$
DECLARE
j json;
cg json;
so json;
v_cg_id integer;
v_so_id integer;
BEGIN
j := "Json"::json;
cg := (j->>'custom_geometry')::json;
so := (j->>'simple_observation')::json;
v_cg_id := cg->>'id';
IF v_cg_id IS NULL THEN
INSERT INTO data.custom_geometry
(name, person_id)
VALUES (cg->>'name', auth.get_context_person_id())
RETURNING id INTO v_cg_id;
ELSE
UPDATE data.custom_geometry
SET name = cg->>'name'
WHERE id = v_cg_id;
END IF;
v_so_id := so->>'id';
IF v_so_id IS NULL THEN
INSERT INTO data.simple_observation
(name, value, comment, indicator_id, date, custom_geometry_id)
VALUES (so->>'name', (so->>'value')::FLOAT4, so->>'comment', (so->>'indicator_id')::INT, (so->>'date')::date, v_cg_id)
RETURNING id INTO v_so_id;
ELSE
UPDATE data.simple_observation
SET name = so->>'name', value = (so->>'value')::FLOAT4, comment = so->>'comment', indicator_id = (so->>'indicator_id')::INT, date = (so->>'date')::date
WHERE id = v_so_id;
END IF;
RETURN json_build_object('key', v_cg_id, 'simple_observation_id', v_so_id);
END $function$
*/
}
/**
* @function site_itrig
* @memberof data
* @description Site itrig
* @returns {trigger}
*/
function site_itrig() {
/*
CREATE OR REPLACE FUNCTION data.site_itrig()
RETURNS trigger
LANGUAGE plpgsql
AS $function$
BEGIN
INSERT INTO data.site_sampling_checklist (site_id) values (NEW.id);
RETURN NEW;
END;
$function$
*/
}
/**
* @function test
* @memberof data
* @description Test
* @param {text} Params
* @param {integer} PersonId
* @param {integer} LangId
* @returns {Object} character_varying keydouble_precision latdouble_precision zemljopisna_duljina
*/
function test() {
/*
CREATE OR REPLACE FUNCTION data.test("Params" text, "PersonId" integer, "LangId" integer)
RETURNS TABLE(key character varying, lat double precision, zemljopisna_duljina double precision)
LANGUAGE plpgsql
AS $function$
BEGIN
RETURN QUERY (
SELECT p.point_key, p.lat, p.lon
FROM data.point p
);
END $function$
*/
}
/**
* @function test_overload
* @overload test
* @memberof data
* @description Test
* @returns {void}
*/
function test_overload() {
/*
CREA
TE OR REPLACE FUNCTION data.test()
RETURNS void
LANGUAGE plpython3u
AS $function$
import os
# Logic to delete the file
file_path = "/uploads/107.jpg"
plpy.notice("The file path to delete is: " + file_path + " " + os.path.realpath(file_path))
plpy.notice(os.geteuid())
#if os.path.isfile(file_path):
# plpy.notice("Deleting")
# os.remove(file_path)
os.remove(file_path)
return None # Returning None for trigger function
$function$
*/
}
/**
* @function testpp
* @memberof data
* @description Testpp
* @returns {void}
*/
function testpp() {
/*
CREA
TE OR REPLACE FUNCTION data.testpp()
RETURNS void
LANGUAGE plperlu
AS $function$
unlink("/uploads/107.jpg") or die "Cannot delete file: $!";
$function$
*/
}
/**
* @function update_attribute_description
* @memberof data
* @description Update attribute description
* @param {integer} PointId
* @param {integer} IndicatorId
* @param {integer} DataSourceId
* @param {character_varying} Date
* @param {integer} Value
* @param {integer} DepthId
* @returns {void}
*/
function update_attribute_description() {
/*
CREATE OR REPLACE FUNCTION data.update_attribute_description("PointId" integer, "IndicatorId" integer, "DataSourceId" integer, "Date" character varying, "Value" integer, "DepthId" integer)
RETURNS void
LANGUAGE plpgsql
AS $function$
DECLARE v_attribute_description_id int;
BEGIN
SELECT id INTO v_attribute_description_id FROM data.attribute_description a WHERE indicator_id = "IndicatorId" AND value = "Value";
IF NOT FOUND THEN
DELETE FROM data.attribute WHERE point_id = "PointId" AND data_source_id = "DataSourceId" AND date = "Date"::date AND (depth_id = "DepthId" OR "DepthId" IS NULL);
ELSE
UPDATE data.attribute
SET attribute_description_id = v_attribute_description_id
WHERE point_id = "PointId" AND data_source_id = "DataSourceId" AND date = "Date"::date AND (depth_id = "DepthId" OR "DepthId" IS NULL);
IF NOT FOUND THEN
INSERT INTO data.attribute (point_id, indicator_id, data_source_id, date, attribute_description_id, depth_id)
VALUES ("PointId", "IndicatorId", "DataSourceId", "Date"::date, v_attribute_description_id, "DepthId");
END IF;
END IF;
END $function$
*/
}
/**
* @function update_compass
* @memberof data
* @description Update compass for a custom geometry file (image)
* @param {integer} PersonId
* @param {integer} Id
* @param {integer} Value
* @returns {void}
*/
function update_compass() {
/*
CREATE OR REPLACE FUNCTION data.update_compass("Id" integer, "Value" integer)
RETURNS void
LANGUAGE plpgsql
AS $function$
DECLARE
DECLARE v_RowCountInt INT;
BEGIN
UPDATE data.image f
SET compass = "Value"
WHERE id = "Id"
AND EXISTS (
SELECT 1 FROM data.image i
INNER JOIN data.simple_observation so ON i.simple_observation_id = so.id
INNER JOIN data.custom_geometry g ON so.custom_geometry_id = g.id
INNER JOIN auth.vw_partner vp ON g.person_id = vp.user_id AND vp.partner_user_id = auth.get_context_person_id()
);
GET DIAGNOSTICS v_RowCountInt = ROW_COUNT;
IF v_RowCountInt = 0 THEN
SELECT meta.raise_error(4);
END IF;
END;
$function$
*/
}
/**
* @function update_depth_lists
* @memberof data
* @description Update depth lists
* @returns {void}
*/
function update_depth_lists() {
/*
CREATE OR REPLACE FUNCTION data.update_depth_lists()
RETURNS void
LANGUAGE plpgsql
AS $function$
BEGIN
WITH d AS (
select DISTINCT s.id, d.name
from data.shdc s
INNER JOIN data.shdc_file f ON f.shdc_id = s.id
LEFT JOIN data.depth d ON f.depth_id = d.id
ORDER BY s.id, d.name
)
UPDATE data.shdc s SET depth_list = (SELECT string_agg(name, ', ') FROM d WHERE d.id = s.id) WHERE id > 0;
WITH d AS (
select DISTINCT s.id, f.value
from data.shdc s
INNER JOIN data.shdc_file f ON f.shdc_id = s.id
ORDER BY s.id, f.value
)
UPDATE data.shdc s SET confidence_list = (SELECT string_agg(value, ', ') FROM d WHERE d.id = s.id) WHERE id > 0;
END $function$
*/
}
/**
* @function update_geometry_statistics
* @memberof data
* @description Update geometry statistics
* @param {text} Json
* @returns {void}
*/
function update_geometry_statistics() {
/*
CREATE OR REPLACE FUNCTION data.update_geometry_statistics("Json" text)
RETURNS void
LANGUAGE plpgsql
AS $function$
DECLARE r RECORD;
BEGIN
SELECT * INTO r FROM jsonb_to_record("Json"::jsonb) AS rec (
parent_id int,
geometry_type_id int,
indicator_id int,
data_source_id int,
min float4,
max float4,
mean float4,
median float4,
q1 float4,
q3 float4,
stdev float4,
n integer,
depth_id integer,
time_span varchar,
x float[],
y int[]);
UPDATE data.geometry_statistics SET
data_source_id = r.data_source_id,
min = r.min,
max = r.max,
mean = r.mean,
median = r.median,
q1 = r.q1,
q3 = r.q3,
stdev = r.stdev,
n = r.n,
x = r.x,
y = r.y
WHERE parent_id = r.parent_id AND geometry_type_id = r.geometry_type_id AND indicator_id = r.indicator_id AND depth_id = r.depth_id AND time_span = r.time_span;
IF NOT FOUND THEN
INSERT INTO data.geometry_statistics (parent_id, geometry_type_id, indicator_id, data_source_id, min, max, mean, median, q1, q3, stdev, n, depth_id, time_span, x, y)
VALUES (r.parent_id, r.geometry_type_id, r.indicator_id, r.data_source_id, r.min, r.max, r.mean, r.median, r.q1, r.q3, r.stdev, r.n, r.depth_id, r.time_span, r.x, r.y);
END IF;
END $function$
*/
}
/**
* @function update_geometry_statistics_from_points
* @memberof data
* @description Update geometry statistics from points
* @param {integer} DataSourceId
* @returns {void}
*/
function update_geometry_statistics_from_points() {
/*
CREATE OR REPLACE FUNCTION data.update_geometry_statistics_from_points("DataSourceId" integer)
RETURNS void
LANGUAGE plpgsql
AS $function$
BEGIN
WITH vf AS (
SELECT
g.parent_id,
g.geometry_type_id,
m.indicator_id,
m.data_source_id,
m.depth_id,
ROUND(m.value::numeric, 2) value,
COUNT(*) AS frequency
FROM data.vw_geometry g
INNER JOIN data.point p ON ST_Contains(g.geom, p.geom)
INNER JOIN data.measurement m ON p.id = m.point_id AND p.data_source_id = m.data_source_id
WHERE m.data_source_id = "DataSourceId"
GROUP BY g.parent_id, g.geometry_type_id, m.indicator_id, m.data_source_id, m.depth_id, m.value
),
t AS (
SELECT
vf.parent_id,
vf.indicator_id,
vf.data_source_id,
MIN(vf.value) AS min,
MAX(vf.value) AS max,
AVG(vf.value) AS mean,
PERCENTILE_DISC(0.50) WITHIN GROUP (ORDER BY vf.value) AS median,
PERCENTILE_DISC(0.25) WITHIN GROUP (ORDER BY vf.value) AS q1,
PERCENTILE_DISC(0.75) WITHIN GROUP (ORDER BY vf.value) AS q3,
STDDEV(vf.value) AS stdev,
COUNT(*) AS n,
d.name depth,
TO_CHAR(ds.date_from, 'YYYYMMDD') || '/' || TO_CHAR(ds.date_to, 'YYYYMMDD') time_span,
vf.geometry_type_id,
ARRAY_AGG(vf.value ORDER BY vf.value) AS x, -- X array (values)
ARRAY_AGG(vf.frequency ORDER BY vf.value) AS y -- Y array (frequencies)
FROM vf
INNER JOIN data.depth d ON vf.depth_id = d.id
INNER JOIN data.data_source ds ON vf.data_source_id = ds.id
GROUP BY vf.parent_id, vf.geometry_type_id, vf.indicator_id, vf.data_source_id, d.name, ds.date_from, ds.date_to
)
INSERT INTO data.geometry_statistics (parent_id, indicator_id, data_source_id, min, max, mean, median, q1, q3, stdev, n, depth, time_span, geometry_type_id, x, y)
SELECT * FROM t
ON CONFLICT (parent_id, geometry_type_id, indicator_id, data_source_id, depth)
DO UPDATE SET
min = EXCLUDED.min,
max = EXCLUDED.max,
mean = EXCLUDED.mean,
median = EXCLUDED.median,
q1 = EXCLUDED.q1,
q3 = EXCLUDED.q3,
stdev = EXCLUDED.stdev,
n = EXCLUDED.n,
x = EXCLUDED.x,
y = EXCLUDED.y;
END $function$
*/
}
/**
* @function update_taxa
* @memberof data
* @description Update taxa
* @param {text} Json
* @returns {void}
*/
function update_taxa() {
/*
CREATE OR REPLACE FUNCTION data.update_taxa("Json" text)
RETURNS void
LANGUAGE plpgsql
AS $function$
DECLARE j json;
BEGIN
CREATE TEMP TABLE t AS
select * from jsonb_to_recordset("Json"::jsonb) as j(id int, id_text text, name text, latin_name text, taxa_level_id int, taxa_status_id int, taxa_code_id int, link text, remarks text, reference text, vern text, env text, chrono text, parent_id int, synonym boolean, uncertain boolean, extinct boolean);
INSERT INTO data.taxa(id, id_text, name, latin_name, taxa_level_id, taxa_status_id, taxa_code_id, link, remarks, reference, vern, env, chrono, parent_id, synonym, uncertain, extinct)
SELECT * FROM t;
--j := "Json"::json;
--SELECT * FROM j
--SELECT (j->>'id')::int, j->'id_text', null, j->>'latin_name', (j->>'taxa_level_id')::int, null, (j->>'taxa_code_id')::int,
--j->>'link', j->>'remarks', j->>'reference', j->>'vern', j->>'env', j->>'chrono', (j->>'parent_id')::int,
--(j->>'synonym')::bool, (j->>'uncertain')::bool, (j->>'extinct')::bool;
RETURN;
END $function$
*/
}
/**
* @function update_taxa_code
* @memberof data
* @description Update taxa code
* @param {text} Json
* @returns {void}
*/
function update_taxa_code() {
/*
CREATE OR REPLACE FUNCTION data.update_taxa_code("Json" text)
RETURNS void
LANGUAGE plpgsql
AS $function$
DECLARE j jsonb;
BEGIN
j:= "Json"::jsonb;
INSERT INTO catalog.taxa_code (id, name)
SELECT
value::INT,
key
FROM jsonb_each(j);
RETURN;
END $function$
*/
}
/**
* @function update_taxa_level
* @memberof data
* @description Update taxa level
* @param {text} Json
* @returns {void}
*/
function update_taxa_level() {
/*
CREATE OR REPLACE FUNCTION data.update_taxa_level("Json" text)
RETURNS void
LANGUAGE plpgsql
AS $function$
DECLARE j jsonb;
BEGIN
j:= "Json"::jsonb;
INSERT INTO catalog.taxa_level (id, name)
SELECT
value::INT,
key
FROM jsonb_each(j);
RETURN;
END $function$
*/
}
/**
* @function add_forum
* @memberof general
* @description Add forum
* @param {text} Json
* @returns {integer}
*/
function add_forum() {
/*
CREATE OR REPLACE FUNCTION general.add_forum("Json" text)
RETURNS integer
LANGUAGE plpgsql
AS $function$
DECLARE j json;
v_id INT;
BEGIN
j := "Json"::json;
INSERT INTO general.forum (forum_topic_id, title, person_id, response_forum_id, message)
VALUES ((j->>'forum_topic_id')::int, (j->>'title')::varchar, auth.get_context_person_id(), (j->>'response_forum_id')::int, (j->>'message')::text)
RETURNING id INTO v_id;
RETURN v_id;
END $function$
*/
}
/**
* @function calculate_levels
* @memberof general
* @description Calculate levels in OSM boundary hierarchy
* @returns {void}
*/
function calculate_levels() {
/*
CREATE OR REPLACE FUNCTION general.calculate_levels()
RETURNS void
LANGUAGE plpgsql
AS $function$
BEGIN
WITH RECURSIVE rh AS (
SELECT t.osm_id AS osm_id, 1 AS level
FROM general.boundary t
WHERE t.admin_level = 2
-- LEFT JOIN general.boundary_hierarchy h ON h.child_id = t.osm_id
-- WHERE h.id IS NULL
UNION ALL
SELECT h.child_id, rh.level + 1
FROM general.boundary_hierarchy h
INNER JOIN rh ON h.parent_id = rh.osm_id
)
UPDATE general.boundary t set level = rh.level
FROM rh WHERE t.osm_id = rh.osm_id;
END $function$
*/
}
/**
* @function delete_all_messages
* @memberof general
* @description Delete all chat messages for a person
* @param {integer} PersonId
* @returns {void}
*/
function delete_all_messages() {
/*
CREATE OR REPLACE FUNCTION general.delete_all_messages("PersonId" integer)
RETURNS void
LANGUAGE plpgsql
AS $function$
BEGIN
DELETE FROM general.message WHERE person_id = "PersonId";
RETURN;
END$function$
*/
}
/**
* @function delete_file_from_os
* @memberof general
* @description Delete file from os
* @returns {trigger}
*/
function delete_file_from_os() {
/*
CREATE OR REPLACE FUNCTION general.delete_file_from_os()
RETURNS trigger
LANGUAGE plpgsql
AS $function$
begin
INSERT INTO general.file_delete VALUES (old.id || '.zip');
RETURN OLD;
end;
$function$
*/
}
/**
* @function delete_forum
* @memberof general
* @description Delete forum
* @param {integer} Id
* @returns {void}
*/
function delete_forum() {
/*
CREATE OR REPLACE FUNCTION general.delete_forum("Id" integer)
RETURNS void
LANGUAGE plpgsql
AS $function$
BEGIN
DELETE FROM general.forum
WHERE id = "Id" AND (person_id = auth.get_context_person_id() or auth.get_context_is_admin());
END $function$
*/
}
/**
* @function delete_message
* @memberof general
* @description Delete single chat message
* @param {integer} Id
* @returns {void}
*/
function delete_message() {
/*
CREATE OR REPLACE FUNCTION general.delete_message("Id" integer)
RETURNS void
LANGUAGE plpgsql
AS $function$
BEGIN
DELETE FROM general.message WHERE id = "Id";
RETURN;
END$function$
*/
}
/**
* @function envelope
* @memberof general
* @description Envelope
* @param {character_varying} extent
* @param {integer} srid
* @returns {geometry}
*/
function envelope() {
/*
CREATE OR REPLACE FUNCTION general.envelope(extent character varying, srid integer)
RETURNS geometry
LANGUAGE plpgsql
AS $function$
DECLARE a FLOAT[];
BEGIN
a:= string_to_array(extent, ',')::FLOAT[];
return st_makeenvelope(a[1], a[2], a[3], a[4], srid);
END $function$
*/
}
/**
* @function file_check_download
* @memberof general
* @description File check download
* @param {integer} Id
* @returns {void}
*/
function file_check_download() {
/*
CREATE OR REPLACE FUNCTION general.file_check_download("Id" integer)
RETURNS void
LANGUAGE plpgsql
AS $function$
BEGIN
IF NOT EXISTS (SELECT 1 FROM general.file WHERE id = "Id") THEN
RAISE EXCEPTION 'File not found';
END IF;
IF NOT EXISTS (SELECT 1 FROM general.file WHERE id = "Id" AND public) THEN
RAISE EXCEPTION 'File is not downloadable';
END IF;
END $function$
*/
}
/**
* @function general_country_import_excel
* @memberof general
* @description Import countries from excel
* @param {text} jsonCV
* @param {text} jsonData
* @returns {void}
*/
function general_country_import_excel() {
/*
CREATE OR REPLACE FUNCTION general.general_country_import_excel("jsonCV" text, "jsonData" text)
RETURNS void
LANGUAGE plpgsql
AS $function$
BEGIN
DROP TABLE IF EXISTS t;
CREATE TEMP TABLE t AS
SELECT * FROM json_to_recordset("jsonData"::json) AS J(name VARCHAR, code VARCHAR, region VARCHAR, sub_region VARCHAR);
WITH x AS (
SELECT DISTINCT t.region FROM t
)
INSERT INTO general.region (name)
SELECT x.region FROM x
LEFT JOIN general.region r ON r.name = x.region
WHERE r.id IS NULL;
WITH x AS (
SELECT DISTINCT t.sub_region FROM t
)
INSERT INTO general.sub_region (name)
SELECT x.sub_region FROM x
LEFT JOIN general.sub_region r ON r.name = x.sub_region
WHERE r.id IS NULL;
WITH x AS (
SELECT name, code, region, sub_region FROM t
)
INSERT INTO general.country (name, code, region_id, sub_region_id)
SELECT x.name, x.code, r.id, s.id
FROM x
LEFT JOIN general.region r ON r.name = x.region
LEFT JOIN general.sub_region s ON s.name = x.sub_region
LEFT JOIN general.country c ON c.name = x.name
WHERE c.id IS NULL;
END
$function$
*/
}
/**
* @function get_ai_model
* @memberof general
* @description Get ai model
* @param {integer} Id
* @returns {Object} integer idcharacter_varying namecharacter_varying urlcharacter_varying usernamecharacter_varying passwordjson bodycharacter_varying methodcharacter_varying answer
*/
function get_ai_model() {
/*
CREATE OR REPLACE FUNCTION general.get_ai_model("Id" integer)
RETURNS TABLE(id integer, name character varying, url character varying, username character varying, password character varying, body json, method character varying, answer character varying)
LANGUAGE plpgsql
AS $function$
BEGIN
RETURN QUERY (
SELECT a.id, a.name, a.url, a.username, a.password, a.body, m.name method, a.answer FROM general.ai_model a
INNER JOIN general.method m ON m.id = a.method_id
WHERE a.id = "Id"
);
END $function$
*/
}
/**
* @function get_ai_models
* @memberof general
* @description Get ai models
* @returns {Object}
* @property {integer} value
* @property {character_varying} label
*/
function get_ai_models() {
/*
CREATE OR REPLACE FUNCTION general.get_ai_models()
RETURNS TABLE(value integer, label character varying)
LANGUAGE plpgsql
AS $function$
BEGIN
-- Routine body goes here...
RETURN QUERY (
SELECT id, name FROM general.ai_model ORDER BY 2
);
END $function$
*/
}
/**
* @function get_boundaries
* @memberof general
* @description Get OSM boundaries
* @param {integer} Level
* @param {integer} Srid
* @param {integer} Zoom
* @param {varchar} Extent
* @param {integer} IndicatorId
* @returns {json}
*/
function get_boundaries() {
/*
CREATE OR REPLACE FUNCTION general.get_boundaries("Level" integer, "Srid" integer, "Zoom" integer, "Extent" character varying, "IndicatorId" integer)
RETURNS json
LANGUAGE plpgsql
AS $function$
DECLARE bb geometry;
simplify float;
BEGIN
bb := general.envelope ("Extent", "Srid");
bb := st_transform(bb, 3857);
simplify := general.simplify ("Zoom");
RAISE NOTICE '%', bb;
DROP TABLE IF EXISTS c;
CREATE TEMP TABLE c AS
SELECT c.osm_id, v.value, ic.color_code
FROM general.country c
LEFT JOIN data.vw_avg_indicator_values_by_nuts0 v
ON v.nuts_name = c.lucas_code AND v.indicator_id = "IndicatorId"
LEFT JOIN data.vw_indicator_color ic
ON ic.indicator_id = v.indicator_id AND ic.value_from < v.value AND ic.value_to >= v.value
WHERE c.region_id = 2;
RETURN (
SELECT jsonb_build_object (
'type', 'FeatureCollection',
'features', json_agg(st_asgeojson(t.*)::json)
)
FROM (
WITH RECURSIVE rh AS (
SELECT b.osm_id
FROM general.boundary b
INNER JOIN c ON c.osm_id = b.osm_id
WHERE level = 1
AND st_intersects(b.geom, bb)
UNION ALL
SELECT bh.child_id
FROM general.boundary_hierarchy bh
INNER JOIN rh ON bh.parent_id = rh.osm_id
INNER JOIN general.boundary b
ON b.osm_id = bh.child_id
AND b.level BETWEEN 2 AND "Level"
)
SELECT b.id, b.name, b.osm_id, c.value, c.color_code, st_transform(st_simplify(b.geom,simplify, true), "Srid")
FROM rh
INNER JOIN general.boundary b ON b.osm_id = rh.osm_id
INNER JOIN c ON c.osm_id = b.osm_id
) t
);
END$function$
*/
}
/**
* @function get_boundary
* @memberof general
* @description Get boundary by OsmId
* @param {integer} OsmId
* @param {integer} Srid
* @returns {json}
*/
function get_boundary() {
/*
CREATE OR REPLACE FUNCTION general.get_boundary("OsmId" integer, "Srid" integer)
RETURNS json
LANGUAGE plpgsql
AS $function$
BEGIN
RETURN (
SELECT jsonb_build_object (
'type', 'FeatureCollection',
'features', json_agg(st_asgeojson(t.*)::json)
)
FROM (
SELECT b.id, b.name, b.osm_id, st_transform(geom, "Srid") geom
FROM general.boundary b
WHERE b.osm_id = "OsmId"
) t
);
END$function$
*/
}
/**
* @function get_chats
* @memberof general
* @description Get chats
* @param {integer} RoomId
* @returns {Object} integer idinteger room_idinteger person_idcharacter_varying messagetimestamp_with_time_zone time_createdcharacter_varying name
*/
function get_chats() {
/*
CREATE OR REPLACE FUNCTION general.get_chats("RoomId" integer)
RETURNS TABLE(id integer, room_id integer, person_id integer, message character varying, time_created timestamp with time zone, name character varying)
LANGUAGE plpgsql
AS $function$
BEGIN
RETURN QUERY (
SELECT c.*, COALESCE(p.nickname, p.first_name) name
FROM general.chat c
INNER JOIN auth.person p ON p.id = c.person_id
WHERE c.room_id = "RoomId"
ORDER BY c.time_created
);
END $function$
*/
}
/**
* @function get_children_boundaries
* @memberof general
* @description Get children boundaries
* @param {integer} OsmId
* @param {integer} Srid
* @returns {json}
*/
function get_children_boundaries() {
/*
CREATE OR REPLACE FUNCTION general.get_children_boundaries("OsmId" integer, "Srid" integer)
RETURNS json
LANGUAGE plpgsql
AS $function$
BEGIN
RETURN (
SELECT jsonb_build_object (
'type', 'FeatureCollection',
'features', json_agg(st_asgeojson(t.*)::json)
)
FROM (
SELECT b.id, name, osm_id, st_transform(geom, "Srid")
FROM general.boundary_hierarchy h
INNER JOIN general.boundary b ON b.osm_id = h.child_id
WHERE parent_id = "OsmId" -- AND parent_distance = 1
) t
);
END$function$
*/
}
/**
* @function get_forum
* @memberof general
* @description Get forum
* @param {integer} Id
* @returns {Object} integer idinteger levelinteger response_forum_idcharacter_varying titletext messagetimestamp_with_time_zone time_createdtimestamp_with_time_zone time_modifiedinteger person_idcharacter_varying author
*/
function get_forum() {
/*
CREATE OR REPLACE FUNCTION general.get_forum("Id" integer)
RETURNS TABLE(id integer, level integer, response_forum_id integer, title character varying, message text, time_created timestamp with time zone, time_modified timestamp with time zone, person_id integer, author character varying)
LANGUAGE plpgsql
AS $function$
BEGIN
RETURN QUERY (
WITH RECURSIVE hierarchy_cte AS (
-- Select the root nodes (rows without parents)
SELECT *, 1 AS level, f.time_modified::varchar path
FROM general.forum f
WHERE f.forum_topic_id = "Id" AND f.response_forum_id IS NULL
UNION ALL
-- Recursive part: Select the child nodes
SELECT f.*, cte.level + 1, cte.path || f.time_modified::varchar
FROM general.forum f
INNER JOIN hierarchy_cte cte ON f.response_forum_id = cte.id
)
SELECT h.id, h.level, h.response_forum_id, h.title, h.message, h.time_created, h.time_modified, p.id person_id, COALESCE(p.nickname, p.first_name) author
FROM hierarchy_cte h
LEFT JOIN auth.person p ON p.id = h.person_id
ORDER BY path
);
END $function$
*/
}
/**
* @function get_mail_msg
* @memberof general
* @description Get mail msg
* @param {integer} TemplateId
* @param {integer} ProviderId
* @returns {Object} character_varying SenderFromcharacter_varying SenderNamecharacter_varying Smtpinteger Portinteger EmailSslIdcharacter_varying Usernamecharacter_varying Passwordtext Subjecttext Bodycharacter_varying InternalName
*/
function get_mail_msg() {
/*
CREATE OR REPLACE FUNCTION general.get_mail_msg("TemplateId" integer, "ProviderId" integer)
RETURNS TABLE("SenderFrom" character varying, "SenderName" character varying, "Smtp" character varying, "Port" integer, "EmailSslId" integer, "Username" character varying, "Password" character varying, "Subject" text, "Body" text, "InternalName" character varying)
LANGUAGE plpgsql
AS $function$
BEGIN
RETURN QUERY (
SELECT ep.sender_from, ep.sender_name,
ep.smtp, ep.port, ep.email_ssl_id, ep.username, meta.decrypt_varchar(ep.password),
et.subject, et.body, ep.internal_name
FROM general.email_provider ep
LEFT JOIN data.email_template et ON et.id = "TemplateId"
WHERE ep.id = "ProviderId"
);
END $function$
*/
}
/**
* @function get_messages
* @memberof general
* @description Get chat messages for a person
* @param {integer} PersonId
* @returns {Object}
* @property {integer} id
* @property {integer} parent_id
* @property {text} message
* @property {timestamp_without_time_zone} time_modified
*/
function get_messages() {
/*
CREATE OR REPLACE FUNCTION general.get_messages()
RETURNS TABLE(id integer, prompt text, response text, time_modified timestamp without time zone)
LANGUAGE plpgsql
AS $function$
BEGIN
RETURN QUERY (
SELECT m.id, m.prompt, m.response, m.time_modified
FROM general.message m
WHERE m.person_id = auth.get_context_person_id()
ORDER BY time_modified
);
RETURN;
END$function$
*/
}
/**
* @function get_all_nuts
* @memberof general
* @description Get all nuts
* @param {integer} Id
* @param {integer} Srid
* @returns {json}
*/
function get_nuts() {
/*
CREATE OR REPLACE FUNCTION general.get_nuts("Id" integer, "Srid" integer)
RETURNS json
LANGUAGE plpgsql
AS $function$
BEGIN
RETURN (
SELECT jsonb_build_object (
'type', 'FeatureCollection',
'features', json_agg(st_asgeojson(t.*)::json)
)
FROM (
SELECT b.id, b.name_latn, b.levl_code, '#FF0000' color_code, '#FF00003F' fill_color_code, st_transform(geom, "Srid") geom
FROM general.nuts b
WHERE b.id = "Id"
) t
);
END$function$
*/
}
/**
* @function get_srids
* @memberof general
* @description Get srids
* @returns {json}
*/
function get_srids() {
/*
CREATE OR REPLACE FUNCTION general.get_srids()
RETURNS json
LANGUAGE plpgsql
AS $function$
BEGIN
RETURN (
SELECT '[3857, 3035]'::json
);
END$function$
*/
}
/**
* @function import_osm_boundaries
* @memberof general
* @description Import osm boundaries from planet_osm_polygon and planet_osm_rels tables
* @returns {void}
*/
function import_osm_boundaries() {
/*
CREATE OR REPLACE PROCEDURE general.import_osm_boundaries()
LANGUAGE plpgsql
AS $procedure$
BEGIN
delete from general.boundary;
delete from general.boundary_hierarchy;
insert into general.boundary (osm_id, admin_level, name, local_name, geom)
SELECT r.id, ((r.tags::hstore)->'admin_level')::int, COALESCE((r.tags::hstore)->'name:en', p.name), p.name, p.way
FROM osm.planet_osm_rels r
INNER JOIN osm.planet_osm_polygon p ON ABS(p.osm_id) = r.id
WHERE textregexeq((r.tags::hstore)->'admin_level','^\d+$');
INSERT INTO general.boundary_hierarchy(parent_id, child_id)
WITH T AS (
SELECT r.id, unnest(r.parts) cid
from osm.planet_osm_rels r
WHERE textregexeq((r.tags::hstore)->'admin_level','^\d+$')
)
SELECT T.*
FROM T
INNER JOIN osm.planet_osm_rels r ON R.id = cid;
-- CALL general.update_parent_distance();
SELECT general.calculate_levels();
END $procedure$
*/
}
/**
* @function save_chat
* @memberof general
* @description Save chat
* @param {integer} PersonId
* @param {integer} RoomId
* @param {character_varying} Message
* @returns {json}
*/
function save_chat() {
/*
CREATE OR REPLACE FUNCTION general.save_chat("PersonId" integer, "RoomId" integer, "Message" character varying)
RETURNS json
LANGUAGE plpgsql
AS $function$
DECLARE v_id INT;
v_time_created timestamptz;
BEGIN
INSERT INTO general.chat AS c(room_id, person_id, message)
VALUES ("RoomId", "PersonId", "Message")
RETURNING id, time_created INTO v_id, v_time_created;
RETURN json_build_object('id', v_id, 'time_created', v_time_created);
END $function$
*/
}
/**
* @function save_file
* @memberof general
* @description Save file
* @param {character_varying} FileId
* @param {character_varying} Name
* @param {integer} Size
* @param {integer} ZippedSize
* @returns {integer}
*/
function save_file() {
/*
CREATE OR REPLACE FUNCTION general.save_file("FileId" character varying, "Name" character varying, "Size" integer, "ZippedSize" integer)
RETURNS integer
LANGUAGE plpgsql
AS $function$
DECLARE v_id INT;
BEGIN
INSERT INTO general.file (name, size, zipped_size, original_name, file_id, time_created)
VALUES ("Name", "Size", "ZippedSize", "Name", "FileId", now())
RETURNING id INTO v_id;
RETURN v_id;
END $function$
*/
}
/**
* @function save_message
* @memberof general
* @description Save chat message
* @param {integer} PersonId
* @param {text} Message
* @param {integer} ParentId
* @returns {integer}
*/
function save_message() {
/*
CREATE OR REPLACE FUNCTION general.save_message("PersonId" integer, "Prompt" text, "Response" text)
RETURNS integer
LANGUAGE plpgsql
AS $function$
DECLARE v_id INT;
BEGIN
-- Routine body goes here...
INSERT INTO general.message (person_id, prompt, response)
VALUES ("PersonId", "Prompt", "Response")
RETURNING id INTO v_id
;
RETURN v_id;
END$function$
*/
}
/**
* @function set_children_geometry
* @memberof general
* @description Set children geometry and properties in the database from the JSON object passed as argument
* @param {text} Properties
* @param {text} Geometry
* @returns {void}
*/
function set_children_geometry() {
/*
CREATE OR REPLACE FUNCTION general.set_children_geometry("Properties" text, "Geometry" text)
RETURNS void
LANGUAGE plpgsql
AS $function$
DECLARE p json;
DECLARE parents VARCHAR;
BEGIN
p := "Properties"::json;
parents := replace((p->'parents')::varchar, '"', '');
DELETE FROM general.boundary_hierarchy WHERE child_id = abs((p->'osm_id')::varchar::int);
DELETE FROM general.boundary WHERE osm_id = abs((p->'osm_id')::varchar::int);
IF (p->'admin_level')::varchar != 'null' THEN
INSERT INTO general.boundary (osm_id, admin_level, name, local_name, geom)
SELECT abs((p->'osm_id')::varchar::int),
(p->'admin_level')::varchar::int,
REPLACE ((p->'name')::varchar, '"', ''),
REPLACE ((p->'local_name')::varchar, '"', ''),
st_transform(st_multi(st_geomfromgeojson("Geometry")), 3035);
IF parents IS NOT null AND parents != 'null' THEN
INSERT INTO general.boundary_hierarchy (parent_id, child_id)
SELECT abs(x::int), abs(y::int) FROM (
SELECT unnest(string_to_array(parents, ',')) x, (p->'osm_id')::varchar y
) t;
END IF;
END IF;
--INSERT INTO meta.trace (text)
--VALUES (abs((p->'osm_id')::varchar::int)::VARCHAR);
RETURN;
END$function$
*/
}
/**
* @function set_nuts
* @memberof general
* @description Set nuts data from geojson to database table
* @param {text} Properties
* @param {text} Geometry
* @returns {void}
*/
function set_nuts() {
/*
CREATE OR REPLACE FUNCTION general.set_nuts("Properties" text, "Geometry" text)
RETURNS void
LANGUAGE plpgsql
AS $function$
DECLARE p json;
BEGIN
p := "Properties"::json;
DELETE FROM general.nuts WHERE nuts_id = (p->'NUTS_ID')::varchar;
INSERT INTO general.nuts (nuts_id, levl_code, cntr_code, name_latn, nuts_name, mount_type, urbn_type, coast_type, fid, geom)
VALUES(
(p->>'NUTS_ID')::varchar,
(p->>'LEVL_CODE')::int,
(p->>'CNTR_CODE')::VARCHAR,
(p->>'NAME_LATN')::varchar,
(p->>'NUTS_NAME')::VARCHAR,
(p->>'MOUNT_TYPE')::int,
(p->>'URBN_TYPE')::int,
(p->>'COAST_TYPE')::int,
(p->>'FID')::varchar,
-- st_transform(st_multi(st_geomfromgeojson("Geometry")), 3035);
st_multi(st_setsrid(st_geomfromgeojson("Geometry"), 3035))
);
RETURN;
END$function$
*/
}
/**
* @function simplify
* @memberof general
* @description Simplify
* @param {integer} Zoom
* @returns {double_precision}
*/
function simplify() {
/*
CREATE OR REPLACE FUNCTION general.simplify("Zoom" integer)
RETURNS double precision
LANGUAGE plpgsql
AS $function$
BEGIN
IF ("Zoom" <= 5) THEN
RETURN 2000;
ELSIF ("Zoom" <= 6) THEN
RETURN 1000;
ELSIF ("Zoom" <= 7) THEN
RETURN 500;
ELSIF ("Zoom" <= 8) THEN
RETURN 300;
ELSIF ("Zoom" <= 9) THEN
RETURN 200;
ELSIF ("Zoom" <= 10) THEN
RETURN 100;
ELSIF ("Zoom" <= 11) THEN
RETURN 70;
ELSIF ("Zoom" <= 12) THEN
RETURN 50;
ELSIF ("Zoom" <= 13) THEN
RETURN 20;
ELSIF ("Zoom" <= 14) THEN
RETURN 10;
ELSE
RETURN 1;
END IF;
END $function$
*/
}
/**
* @function update_forum
* @memberof general
* @description Update forum
* @param {text} Json
* @returns {void}
*/
function update_forum() {
/*
CREATE OR REPLACE FUNCTION general.update_forum("Json" text)
RETURNS void
LANGUAGE plpgsql
AS $function$
DECLARE j json;
BEGIN
j := "Json"::json;
UPDATE general.forum
SET title = (j->>'title')::varchar, message = (j->>'message')::text
WHERE id = (j->>'id')::int;
END $function$
*/
}
/**
* @function a_crud_temp
* @memberof meta
* @description A crud temp
* @param {character_varying} SchemaName
* @param {character_varying} TableName
* @param {boolean} ForDetail
* @param {character_varying} MasterKey
* @param {boolean} WithOwnership
* @param {boolean} ForIsA
* @returns {void}
*/
function a_crud_temp() {
/*
CREATE OR REPLACE FUNCTION meta.a_crud_temp("SchemaName" character varying, "TableName" character varying, "ForDetail" boolean DEFAULT false, "MasterKey" character varying DEFAULT ''::character varying, "WithOwnership" boolean DEFAULT false, "ForIsA" boolean DEFAULT false)
RETURNS void
LANGUAGE plpgsql
AS $function$
DECLARE
col_name VARCHAR;
col_type VARCHAR;
table_list VARCHAR := '';
column_list VARCHAR := '';
select_column_list VARCHAR := '';
column_value_list VARCHAR := '';
update_list VARCHAR := '';
ref_col_list VARCHAR := '';
ref_val_list VARCHAR := '';
join_list VARCHAR := '';
ref_schema_name VARCHAR;
ref_table_name VARCHAR;
ref_col_name VARCHAR;
ref_disp_col_name VARCHAR := '';
pk_column VARCHAR;
pk_type VARCHAR;
sql VARCHAR;
name varchar;
tableapi_name varchar;
v_colatts json;
isASql varchar = '';
BEGIN
DROP TABLE IF EXISTS x;
CREATE TEMP TABLE x AS
SELECT * FROM meta.get_table_cols("SchemaName", "TableName");
tableapi_name := format('%s_%s', "SchemaName", "TableName");
SELECT column_name, data_type INTO pk_column, pk_type
FROM x WHERE ordinal_number = 1;
-- Construct column list for INSERT and UPDATE statements
FOR ref_schema_name, ref_table_name, col_name, col_type IN
SELECT referenced_schema_name, referenced_table_name, column_name, data_type FROM x
WHERE data_type != 'geometry' AND NOT is_computed
LOOP
select_column_list := select_column_list || 't.' || col_name || ', ';
if ref_schema_name IS NOT NULL THEN
name := ref_schema_name || '_' || ref_table_name || '__' || col_name;
ELSE
name := col_name;
END IF;
table_list := table_list || name || ' ' || col_type || ', ';
IF col_name != pk_column THEN
column_list := column_list || col_name || ', ';
column_value_list := column_value_list ||
CASE WHEN col_name = 'person_id' AND "WithOwnership" THEN 'auth.get_context_person_id()' ELSE
'(json_data->>' || QUOTE_LITERAL(col_name) || ')::' || col_type END
|| ', ';
update_list := update_list || E'\n ' || col_name || ' = (json_data->>' || QUOTE_LITERAL(col_name) || ')::' || col_type || ', ';
END IF;
END LOOP;
FOR ref_schema_name, ref_table_name, ref_col_name, col_name, ref_disp_col_name, col_type IN
SELECT referenced_schema_name, referenced_table_name, referenced_column_name, column_name, referenced_display_column_name, data_type
FROM x WHERE x.referenced_column_name IS NOT NULL
LOOP
ref_col_list := ref_col_list || ', ' || ref_schema_name || '_' || ref_table_name || '__' || col_name || '_val VARCHAR';
ref_val_list := ref_val_list || ', ' || col_name || '.' || ref_disp_col_name;
join_list := join_list || E'\n LEFT JOIN '
|| ref_schema_name || '.' || ref_table_name || ' ' || col_name
|| ' ON ' || col_name || '.' || ref_col_name || ' = t.' || col_name;
RAISE NOTICE '% % % % %', 'Creating lookup', ref_schema_name, ref_table_name, ref_disp_col_name, col_type;
PERFORM meta.lookup(ref_schema_name, ref_table_name, ref_disp_col_name, col_type);
END LOOP;
-- Remove trailing commas
select_column_list := SUBSTRING(select_column_list FROM 1 FOR LENGTH(select_column_list) - 2);
table_list := SUBSTRING(table_list FROM 1 FOR LENGTH(table_list) - 2);
column_list := SUBSTRING(column_list FROM 1 FOR LENGTH(column_list) - 2);
column_value_list := SUBSTRING(column_value_list FROM 1 FOR LENGTH(column_value_list) - 2);
update_list := SUBSTRING(update_list FROM 1 FOR LENGTH(update_list) - 2);
-- Create SELECT function
name = tableapi_name || '_r';
if ("ForDetail" AND "MasterKey" = '') THEN
name = tableapi_name || '_s_r';
END IF;
sql := '
DROP FUNCTION IF EXISTS zzglc.' || name || ' (' ||
CASE WHEN "ForDetail" THEN '"Key" integer' ELSE '' END
|| ');' ||
'CREATE OR REPLACE FUNCTION zzglc.' || name || ' (' ||
CASE WHEN "ForDetail" THEN '"Key" integer' ELSE '' END
|| ')
RETURNS TABLE (' || table_list || ref_col_list || ') AS $F$
BEGIN
RETURN QUERY (
SELECT ' || select_column_list || ref_val_list || '
FROM ' || "SchemaName" || '.' || "TableName" || ' t ' ||
CASE WHEN "WithOwnership" THEN '
LEFT JOIN auth.vw_partner vwp ON vwp.user_id = t.person_id AND vwp.partner_user_id = auth.get_context_person_id() ' ELSE '' END
|| join_list ||
CASE WHEN "ForDetail" THEN '
WHERE t.' || CASE WHEN "MasterKey" > '' THEN "MasterKey" ELSE 'id' END || ' = "Key"'
WHEN "WithOwnership" THEN '
WHERE vwp.user_id = auth.get_context_person_id() OR auth.get_context_is_admin()'
ELSE '' END || '
ORDER BY 2
);
END $F$ LANGUAGE plpgsql;';
--RAISE NOTICE '%', sql;
EXECUTE sql;
IF "ForDetail" THEN
RETURN;
end if;
-- Create INSERT function
sql := '
DROP FUNCTION IF EXISTS zzglc.' || tableapi_name || '_c;
CREATE OR REPLACE FUNCTION zzglc.' || tableapi_name || '_c ("Json" varchar)
RETURNS ' || pk_type || ' AS $F$
DECLARE v_id ' || pk_type || ';
DECLARE json_data json;
BEGIN
json_data := "Json";
INSERT INTO ' || "SchemaName" || '.' || "TableName" || ' (' || column_list || ')
VALUES (' || column_value_list || ')
RETURNING id INTO v_id;
RETURN v_id;
END $F$ LANGUAGE plpgsql;';
--RAISE NOTICE '%', sql;
EXECUTE sql;
IF "ForIsA" THEN
isASql := 'IF NOT FOUND THEN
INSERT INTO ' || "SchemaName" || '.' || "TableName" || ' (' || column_list || ')
VALUES (' || column_value_list || ')
RETURNING id INTO v_id;
END IF;';
END IF;
-- Create UPDATE function
sql := '
DROP FUNCTION IF EXISTS zzglc.' || tableapi_name || '_u;
CREATE OR REPLACE FUNCTION zzglc.' || tableapi_name || '_u ("Json" varchar)
RETURNS ' || pk_type || ' AS $F$
DECLARE v_id ' || pk_type || ';
DECLARE json_data json;
BEGIN
json_data := "Json";
v_id := (json_data->>' || QUOTE_LITERAL(pk_column) || ')::' || pk_type || ';
UPDATE ' || "SchemaName" || '.' || "TableName" || ' SET' || update_list || '
WHERE ' || pk_column || ' = v_id;
' || isASql || '
RETURN v_id;
END $F$ LANGUAGE plpgsql;';
RAISE NOTICE '%', sql;
EXECUTE sql;
-- Create DELETE function
sql := '
DROP FUNCTION IF EXISTS zzglc.' || tableapi_name || '_d("Key" integer);
CREATE OR REPLACE FUNCTION zzglc.' || tableapi_name || '_d
( "Key" ' || pk_type || ')
RETURNS VOID AS $F$
BEGIN
DELETE FROM ' || "SchemaName" || '.' || "TableName" || ' WHERE ' || pk_column || ' = "Key";
END;
$F$ LANGUAGE plpgsql;';
EXECUTE sql;
IF NOT EXISTS(SELECT 1 FROM meta.route r WHERE r.path = '/' || "TableName") THEN
INSERT INTO meta.route (name, order_no, path, component, icon, parent, props, offline, public, active)
VALUES (meta.snake_to_sentence("TableName") || 's', 99999, '/' || "TableName", 'table', 'table_chart', NULL, format('{ "tableAPI" : "%s_%s" }',"SchemaName", "TableName")::json, false, false, true) ;
END IF;
-- generate colAtts
select
json_build_object('colAtts',
jsonb_object_agg (column_name, jsonb_build_object('default' , default_value, 'required', not allow_dbnull ))) INTO v_colatts
FROM x
WHERE column_name != 'id' and (default_value IS NOT NULL or allow_dbnull = false);
IF EXISTS (SELECT 1 FROM meta.tableapi_props WHERE tableapi = tableapi_name) THEN
UPDATE meta.tableapi_props SET colatts = v_colatts WHERE tableapi = tableapi_name;
ELSE
INSERT INTO meta.tableapi_props (tableapi, colatts) VALUES (tableapi_name, v_colatts);
END IF;
END $function$
*/
}
/**
* @function add_comment_to_procedure
* @memberof meta
* @description Adds a first version of the comment to the procedure
* @param {character_varying} SchemaName - Name of the schema
* @param {character_varying} ProcName - Name of the proc
* @returns {json}
*/
function add_comment_to_procedure() {
/*
CREATE OR REPLACE FUNCTION meta.add_comment_to_procedure("SchemaName" character varying, "ProcName" character varying)
RETURNS json
LANGUAGE plpgsql
AS $function$
BEGIN
RETURN (
WITH t AS (
SELECT
n.nspname,
p.proname,
pg_get_functiondef(p.oid) AS function_definition,
s.description proc_comment,
a.order_no::INT,
a.param_name,
pg_catalog.format_type(COALESCE (b.param_type, d.param_type), null) AS data_type,
c.input_output,
pg_catalog.format_type(p.prorettype, null) AS return_type
FROM pg_proc p
INNER JOIN pg_namespace n ON (p.pronamespace = n.oid)
LEFT JOIN pg_description s ON s.objoid = p.oid
LEFT JOIN unnest(proargnames) WITH ORDINALITY AS a(param_name, order_no) ON true
LEFT JOIN unnest(proargtypes) WITH ORDINALITY AS b(param_type, bseq) ON a.order_no = b.bseq
LEFT JOIN unnest(proargmodes) WITH ORDINALITY AS c(input_output, cseq) ON a.order_no = c.cseq
LEFT JOIN unnest(proallargtypes) WITH ORDINALITY AS d(param_type, dseq) ON a.order_no = d.dseq
WHERE n.nspname = "SchemaName" AND p.proname = "ProcName"
),
b AS (
SELECT nspname, proname, return_type, function_definition, proc_comment,
json_build_object('param_name', param_name, 'data_type', data_type, 'input_output', input_output) param
FROM t
),
c AS (
SELECT nspname proc_schema, proname proc_name, return_type, function_definition, proc_comment,
json_agg(param) params
FROM b
GROUP BY nspname, proname, return_type, function_definition, proc_comment
)
SELECT json_agg (c.*) FROM c
);
END $function$
*/
}
/**
* @function add_i18n_keys
* @memberof meta
* @description Add i18n keys found in code to the i18n table
* @param {character_varying} Keys
* @returns {void}
*/
function add_i18n_keys() {
/*
CREATE OR REPLACE FUNCTION meta.add_i18n_keys("Keys" character varying)
RETURNS void
LANGUAGE plpgsql
AS $function$
BEGIN
INSERT INTO meta.i18n (key)
SELECT REPLACE(key::VARCHAR, '"', '') FROM json_array_elements("Keys"::json) key
ON CONFLICT(key) DO NOTHING;
END $function$
*/
}
/**
* @function add_timestamp_column
* @memberof meta
* @description Add time_modified timestamp column to table if it does not exist
* @param {character_varying} SchemaName
* @param {character_varying} TableName
* @returns {void}
*/
function add_timestamp_column() {
/*
CREATE OR REPLACE FUNCTION meta.add_timestamp_column("SchemaName" character varying, "TableName" character varying)
RETURNS void
LANGUAGE plpgsql
AS $function$
DECLARE
sql VARCHAR;
BEGIN
IF NOT EXISTS (SELECT 1
FROM pg_attribute
WHERE attrelid = ("SchemaName" || '.' || "TableName")::regclass -- table name optionally schema-qualified
AND attnum > 0
AND NOT attisdropped
AND attname = 'time_modified') THEN
EXECUTE format ('ALTER TABLE %s.%s ADD column time_modified timestamp', "SchemaName", "TableName");
END IF;
EXECUTE format ('UPDATE %s.%s SET time_modified=CURRENT_TIMESTAMP WHERE time_modified IS NULL', "SchemaName", "TableName");
PERFORM meta.add_update_time_modified_trigger("SchemaName", "TableName");
END $function$
*/
}
/**
* @function add_triggers
* @memberof meta
* @description Add triggers to a table to update time_modified and user_modified columns, if they exist.
* @param {character_varying} SchemaName
* @param {character_varying} TableName
* @returns {void}
*/
function add_triggers() {
/*
CREATE OR REPLACE FUNCTION meta.add_triggers("SchemaName" character varying, "TableName" character varying)
RETURNS void
LANGUAGE plpgsql
AS $function$
DECLARE
sql VARCHAR;
BEGIN
IF EXISTS (SELECT 1
FROM pg_attribute
WHERE attrelid = ("SchemaName" || '.' || "TableName")::regclass -- table name optionally schema-qualified
AND attnum > 0
AND NOT attisdropped
AND attname = 'time_modified') THEN
IF EXISTS (SELECT 1
FROM pg_attribute
WHERE attrelid = ("SchemaName" || '.' || "TableName")::regclass -- table name optionally schema-qualified
AND attnum > 0
AND NOT attisdropped
AND attname = 'user_modified') THEN
PERFORM meta.add_update_user_and_time_modified_trigger("SchemaName", "TableName");
ELSE
PERFORM meta.add_update_time_modified_trigger("SchemaName", "TableName");
END IF;
END IF;
END $function$
*/
}
/**
* @function add_update_time_modified_trigger
* @memberof meta
* @description Add update time modified trigger
* @param {character_varying} SchemaName
* @param {character_varying} TableName
* @returns {void}
*/
function add_update_time_modified_trigger() {
/*
CREATE OR REPLACE FUNCTION meta.add_update_time_modified_trigger("SchemaName" character varying, "TableName" character varying)
RETURNS void
LANGUAGE plpgsql
AS $function$
BEGIN
EXECUTE '
CREATE OR REPLACE TRIGGER ' || "TableName" || '_ttrig
BEFORE INSERT OR UPDATE
ON ' || "SchemaName" || '.' || "TableName" || '
FOR EACH ROW
EXECUTE PROCEDURE meta.update_time_modified()
';
END $function$
*/
}
/**
* @function add_update_user_and_time_modified_trigger
* @memberof meta
* @description Add update user and time modified trigger
* @param {character_varying} SchemaName
* @param {character_varying} TableName
* @returns {void}
*/
function add_update_user_and_time_modified_trigger() {
/*
CREATE OR REPLACE FUNCTION meta.add_update_user_and_time_modified_trigger("SchemaName" character varying, "TableName" character varying)
RETURNS void
LANGUAGE plpgsql
AS $function$
BEGIN
EXECUTE '
CREATE OR REPLACE TRIGGER ' || "TableName" || '_ttrig
BEFORE INSERT OR UPDATE
ON ' || "SchemaName" || '.' || "TableName" || '
FOR EACH ROW
EXECUTE PROCEDURE meta.update_user_and_time_modified()
';
END $function$
*/
}
/**
* @function add_user_and_timestamp_column
* @memberof meta
* @description Add user and timestamp column to a table if they do not exist
* @param {character_varying} SchemaName
* @param {character_varying} TableName
* @returns {void}
*/
function add_user_and_timestamp_column() {
/*
CREATE OR REPLACE FUNCTION meta.add_user_and_timestamp_column("SchemaName" character varying, "TableName" character varying)
RETURNS void
LANGUAGE plpgsql
AS $function$
DECLARE
sql VARCHAR;
BEGIN
IF NOT EXISTS (SELECT 1
FROM pg_attribute
WHERE attrelid = ("SchemaName" || '.' || "TableName")::regclass -- table name optionally schema-qualified
AND attnum > 0
AND NOT attisdropped
AND attname = 'time_modified') THEN
EXECUTE format ('ALTER TABLE %s.%s ADD column time_modified timestamp', "SchemaName", "TableName");
EXECUTE format ('ALTER TABLE %s.%s ADD column user_modified_id int4', "SchemaName", "TableName");
END IF;
EXECUTE format ('UPDATE %s.%s SET time_modified=CURRENT_TIMESTAMP WHERE time_modified IS NULL', "SchemaName", "TableName");
PERFORM meta.add_update_user_and_time_modified_trigger("SchemaName", "TableName");
EXECUTE format ('alter table %s.%s add constraint fk_%s_person FOREIGN KEY (user_modified_id) REFERENCES auth.person (id)', "SchemaName", "TableName", "TableName");
END $function$
*/
}
/**
* @function analyze_file
* @memberof meta
* @description Analyze file (detect columns and data types from JSON data and save to import_detail table)
* @param {integer} Id
* @param {text} JsonData
* @returns {void}
*/
function analyze_file() {
/*
CREATE OR REPLACE FUNCTION meta.analyze_file("Id" integer, "JsonData" text)
RETURNS void
LANGUAGE plpgsql
AS $function$
DECLARE debug VARCHAR;
BEGIN
DROP TABLE IF EXISTS t;
CREATE TEMP TABLE t AS
SELECT * FROM json_to_recordset("JsonData"::json) AS J(col_name VARCHAR, col_type VARCHAR);
DELETE FROM meta.import_detail WHERE import_master_id = "Id";
INSERT INTO meta.import_detail (import_master_id, col_name, col_type, target_schema, target_table, target_column, is_fk, is_key, order_no)
--SELECT json_agg(x.*) FROM (
SELECT "Id", t.col_name, dt.name, m.schema_name, m.table_name, meta.camel_to_snake(t.col_name), false, false, ROW_NUMBER() OVER ()
FROM t
INNER JOIN meta.import_master m ON m.id = "Id"
LEFT JOIN meta.data_type dt ON dt.server_data_type = REPLACE(t.col_type, 'System.', '') AND dt.default_type
--) x;
;
RAISE NOTICE '%', debug;
RETURN;
END$function$
*/
}
/**
* @function camel_to_snake
* @memberof meta
* @description Converts text in camel case to snake case
* @param {text} input_text
* @returns {text}
*/
function camel_to_snake() {
/*
CREATE OR REPLACE FUNCTION meta.camel_to_snake(input_text text)
RETURNS text
LANGUAGE plpgsql
AS $function$
DECLARE
output_text text := '';
prev_char text := '';
curr_char text;
BEGIN
IF input_text IS NULL OR input_text = '' THEN --OR input_text ~ ' ' THEN
RETURN input_text;
END IF;
input_text := replace(input_text, ' ', '');
input_text := replace(input_text, '-', '_');
RAISE NOTICE '%', input_text;
FOR i IN 1..length(input_text) LOOP
curr_char := substr(input_text, i, 1);
IF i > 1
AND curr_char = upper(curr_char)
AND prev_char != '_'
AND prev_char != upper(prev_char)
THEN
output_text := output_text || '_' || lower(curr_char);
prev_char = '_';
ELSE
output_text := output_text || lower(curr_char);
prev_char = curr_char;
END IF;
END LOOP;
output_text := replace(output_text, '__', '_');
RETURN output_text;
END;
$function$
*/
}
/**
* @function clean_table
* @memberof meta
* @description Clean table (create a new table keeping the structure and foreign keys)
* @param {text} v_schema_name
* @param {text} v_table_name
* @returns {void}
*/
function clean_table() {
/*
CREATE OR REPLACE FUNCTION meta.clean_table(v_schema_name text, v_table_name text)
RETURNS void
LANGUAGE plpgsql
AS $function$
DECLARE
column_names text[];
new_table_name text;
inbound_foreign_keys pg_constraint[];
outbound_foreign_keys pg_constraint[];
fk record;
tid oid;
cmd text;
BEGIN
-- Create a new table with the same structure as the original table
EXECUTE format('CREATE TABLE %I.new_%I (LIKE %I.%I INCLUDING ALL)', v_schema_name, v_table_name, v_schema_name, v_table_name);
-- Get the list of columns that are not dropped
SELECT ARRAY(SELECT column_name
FROM information_schema.columns
WHERE table_schema = v_schema_name
AND table_name = v_table_name)
INTO column_names;
-- Generate a list of column names for the new table
new_table_name := 'new_' || v_table_name;
tid := (v_schema_name || '.' || v_table_name)::regclass;
-- Copy data from the original table to the new table
cmd := format('INSERT INTO %I.%I OVERRIDING SYSTEM VALUE SELECT %s FROM %I.%I', v_schema_name, new_table_name, array_to_string(column_names, ', '), v_schema_name, v_table_name);
RAISE NOTICE '%', cmd;
EXECUTE cmd;
-- Memorize existing inbound foreign keys
CREATE TEMP TABLE inbound_foreign_keys AS
SELECT
conname,
conrelid::regclass::text AS t,
confrelid::regclass::text AS ft,
string_agg(a.attname, ', ' ORDER BY conkey) AS fkey,
string_agg(b.attname, ', ' ORDER BY confkey) AS rkey,
CASE WHEN confupdtype = 'c' THEN ' ON UPDATE CASCADE' ELSE '' END AS updaction,
CASE WHEN confdeltype = 'c' THEN ' ON DELETE CASCADE' ELSE '' END AS delaction
FROM
pg_constraint
JOIN
pg_attribute a ON a.attrelid = conrelid AND a.attnum = ANY(conkey)
JOIN
pg_attribute b ON b.attrelid = conrelid AND b.attnum = ANY(confkey)
WHERE confrelid = tid
GROUP BY conname, conrelid, confrelid, updaction, delaction;
-- Memorize existing outbound foreign keys
CREATE TEMP TABLE outbound_foreign_keys AS
SELECT
conname,
conrelid::regclass::text AS t,
confrelid::regclass::text AS ft,
string_agg(a.attname, ', ' ORDER BY conkey) AS fkey,
string_agg(b.attname, ', ' ORDER BY confkey) AS rkey,
CASE WHEN confupdtype = 'c' THEN ' ON UPDATE CASCADE' ELSE '' END AS updaction,
CASE WHEN confdeltype = 'c' THEN ' ON DELETE CASCADE' ELSE '' END AS delaction
FROM
pg_constraint
JOIN
pg_attribute a ON a.attrelid = conrelid AND a.attnum = ANY(conkey)
JOIN
pg_attribute b ON b.attrelid = conrelid AND b.attnum = ANY(confkey)
WHERE conrelid = tid
GROUP BY conname, conrelid, confrelid, updaction, delaction;
-- Delete fk's
FOR fk IN SELECT * FROM outbound_foreign_keys
LOOP
EXECUTE format('ALTER TABLE %I.%I DROP CONSTRAINT %s',
v_schema_name, v_table_name, fk.conname);
END LOOP;
FOR fk IN SELECT * FROM inbound_foreign_keys
LOOP
EXECUTE format('ALTER TABLE %I.%I DROP CONSTRAINT %s',
v_schema_name, v_table_name, fk.conname);
END LOOP;
-- Drop the original table
EXECUTE format('DROP TABLE %I.%I CASCADE', v_schema_name, v_table_name);
-- Rename the new table to the original table's name
EXECUTE format('ALTER TABLE %I.%I RENAME TO %I', v_schema_name, new_table_name, v_table_name);
EXECUTE format('ALTER TABLE %I.%I OWNER TO gl', v_schema_name, v_table_name);
-- Recreate outbound foreign keys on the new table
FOR fk IN SELECT * FROM outbound_foreign_keys
LOOP
cmd := format('ALTER TABLE %I.%I ADD CONSTRAINT %s FOREIGN KEY (%s) REFERENCES %s.%s (%s)%s%s',
v_schema_name, fk.t, fk.conname,
fk.fkey,
v_schema_name,
fk.ft,
fk.rkey,
fk.delaction,
fk.updaction);
RAISE NOTICE '%', cmd;
EXECUTE cmd;
END LOOP;
-- Recreate the saved inbound foreign keys
FOR fk IN SELECT * FROM inbound_foreign_keys
LOOP
cmd := format('ALTER TABLE %I.%I ADD CONSTRAINT %s FOREIGN KEY (%s) REFERENCES %s.%s (%s)%s%s',
v_schema_name, fk.t, fk.conname,
fk.fkey,
v_schema_name,
fk.ft,
fk.rkey,
fk.delaction,
fk.updaction);
RAISE NOTICE '%', cmd;
EXECUTE cmd;
END LOOP;
DROP TABLE inbound_foreign_keys;
DROP TABLE outbound_foreign_keys;
END;
$function$
*/
}
/**
* @function clean_value
* @memberof meta
* @description Clean value for insertion into database table depending on type
* @param {character_varying} v
* @param {character_varying} t
* @returns {character_varying}
*/
function clean_value() {
/*
CREATE OR REPLACE FUNCTION meta.clean_value(v character varying, t character varying)
RETURNS character varying
LANGUAGE plpgsql
AS $function$
BEGIN
IF v = '' OR v = 'NA' THEN
RETURN null;
END IF;
IF v = '< LOD' OR v = '< LOD' THEN
RETURN '-999999';
END IF;
IF v = '<0.0' THEN
RETURN '-888888';
END IF;
IF t = 'date' THEN
IF POSITION('/' IN v) > 0 THEN
RETURN to_date(v,'MM/DD/YYYY')::VARCHAR;
ELSE
RETURN to_date(v,'YYYY-MM-DD')::VARCHAR;
END IF;
END IF;
IF t = 'int' OR t = 'integer' THEN
RETURN v::FLOAT::INTEGER::VARCHAR;
END IF;
RETURN v;
END $function$
*/
}
/**
* @function create_route_for_dbfunction
* @memberof meta
* @description Create route for dbfunction
* @param {character_varying} schema_name
* @param {character_varying} procedure_name
* @returns {void}
*/
function create_route_for_dbfunction() {
/*
CREATE OR REPLACE FUNCTION meta.create_route_for_dbfunction(schema_name character varying, procedure_name character varying)
RETURNS void
LANGUAGE plpgsql
AS $function$
BEGIN
IF NOT auth.get_context_is_admin() THEN
RAISE EXCEPTION 'Permission denied';
RETURN;
END IF;
INSERT INTO meta.safe_function (name) VALUES (format('%I.%I', schema_name, procedure_name)::varchar) ON CONFLICT DO NOTHING;
INSERT INTO meta.route (name, order_no, path, component, icon, parent, props, offline, public, active, locked, title)
VALUES (meta.snake_to_sentence(procedure_name), 999999, '/' || procedure_name, 'table', 'table_chart', null,
format('{ "dbFunction" : "%I.%I", "json" : true }', schema_name, procedure_name )::json, false, false, true, false, null);
END $function$
*/
}
/**
* @function crud
* @memberof meta
* @description Crud
* @param {character_varying} SchemaName
* @param {character_varying} TableName
* @param {boolean} ForDetail
* @param {character_varying} MasterKey
* @param {boolean} WithOwnership
* @param {boolean} ForIsA
* @returns {void}
*/
function crud() {
/*
CREATE OR REPLACE FUNCTION meta.crud("SchemaName" character varying, "TableName" character varying, "ForDetail" boolean DEFAULT false, "MasterKey" character varying DEFAULT ''::character varying, "WithOwnership" boolean DEFAULT false, "ForIsA" boolean DEFAULT false)
RETURNS void
LANGUAGE plpgsql
AS $function$
DECLARE
col_name VARCHAR;
col_type VARCHAR;
table_list VARCHAR := '';
column_list VARCHAR := '';
select_column_list VARCHAR := '';
column_value_list VARCHAR := '';
update_list VARCHAR := '';
ref_col_list VARCHAR := '';
ref_val_list VARCHAR := '';
join_list VARCHAR := '';
ref_schema_name VARCHAR;
ref_table_name VARCHAR;
ref_col_name VARCHAR;
ref_disp_col_name VARCHAR := '';
pk_column VARCHAR;
pk_type VARCHAR;
sql VARCHAR;
name varchar;
tableapi_name varchar;
v_colatts json;
isASql varchar = '';
BEGIN
DROP TABLE IF EXISTS x;
CREATE TEMP TABLE x AS
SELECT * FROM meta.get_table_cols("SchemaName", "TableName");
tableapi_name := format('%s_%s', "SchemaName", "TableName");
SELECT column_name, data_type INTO pk_column, pk_type
FROM x WHERE ordinal_number = 1;
-- Construct column list for INSERT and UPDATE statements
FOR ref_schema_name, ref_table_name, col_name, col_type IN
SELECT referenced_schema_name, referenced_table_name, column_name, data_type FROM x
WHERE data_type != 'geometry' AND NOT is_computed
LOOP
select_column_list := select_column_list || 't.' || col_name || ', ';
if ref_schema_name IS NOT NULL THEN
name := ref_schema_name || '_' || ref_table_name || '__' || col_name;
ELSE
name := col_name;
END IF;
table_list := table_list || name || ' ' || col_type || ', ';
IF col_name != pk_column THEN
column_list := column_list || col_name || ', ';
column_value_list := column_value_list ||
CASE WHEN col_name = 'person_id' AND "WithOwnership" THEN 'auth.get_context_person_id()' ELSE
'(json_data->>' || QUOTE_LITERAL(col_name) || ')::' || col_type END
|| ', ';
update_list := update_list || E'\n ' || col_name || ' = (json_data->>' || QUOTE_LITERAL(col_name) || ')::' || col_type || ', ';
END IF;
END LOOP;
FOR ref_schema_name, ref_table_name, ref_col_name, col_name, ref_disp_col_name, col_type IN
SELECT referenced_schema_name, referenced_table_name, referenced_column_name, column_name, referenced_display_column_name, data_type
FROM x WHERE x.referenced_column_name IS NOT NULL
LOOP
ref_col_list := ref_col_list || ', ' || ref_schema_name || '_' || ref_table_name || '__' || col_name || '_val VARCHAR';
ref_val_list := ref_val_list || ', ' || col_name || '.' || ref_disp_col_name;
join_list := join_list || E'\n LEFT JOIN '
|| ref_schema_name || '.' || ref_table_name || ' ' || col_name
|| ' ON ' || col_name || '.' || ref_col_name || ' = t.' || col_name;
RAISE NOTICE '% % % % %', 'Creating lookup', ref_schema_name, ref_table_name, ref_disp_col_name, col_type;
PERFORM meta.lookup(ref_schema_name, ref_table_name, ref_disp_col_name, col_type);
END LOOP;
-- Remove trailing commas
select_column_list := SUBSTRING(select_column_list FROM 1 FOR LENGTH(select_column_list) - 2);
table_list := SUBSTRING(table_list FROM 1 FOR LENGTH(table_list) - 2);
column_list := SUBSTRING(column_list FROM 1 FOR LENGTH(column_list) - 2);
column_value_list := SUBSTRING(column_value_list FROM 1 FOR LENGTH(column_value_list) - 2);
update_list := SUBSTRING(update_list FROM 1 FOR LENGTH(update_list) - 2);
-- Create SELECT function
name = tableapi_name || '_r';
if ("ForDetail" AND "MasterKey" = '') THEN
name = tableapi_name || '_s_r';
END IF;
sql := '
DROP FUNCTION IF EXISTS zzglc.' || name || ' (' ||
CASE WHEN "ForDetail" THEN '"Key" integer' ELSE '' END
|| ');' ||
'CREATE OR REPLACE FUNCTION zzglc.' || name || ' (' ||
CASE WHEN "ForDetail" THEN '"Key" integer' ELSE '' END
|| ')
RETURNS TABLE (' || table_list || ref_col_list || ') AS $F$
BEGIN
RETURN QUERY (
SELECT ' || select_column_list || ref_val_list || '
FROM ' || "SchemaName" || '.' || "TableName" || ' t ' ||
CASE WHEN "WithOwnership" THEN '
LEFT JOIN auth.vw_partner vwp ON vwp.user_id = t.person_id AND vwp.partner_user_id = auth.get_context_person_id() ' ELSE '' END
|| join_list ||
CASE WHEN "ForDetail" THEN '
WHERE t.' || CASE WHEN "MasterKey" > '' THEN "MasterKey" ELSE 'id' END || ' = "Key"'
WHEN "WithOwnership" THEN '
WHERE vwp.user_id = auth.get_context_person_id() OR auth.get_context_is_admin()'
ELSE '' END || '
ORDER BY 2
);
END $F$ LANGUAGE plpgsql;';
--RAISE NOTICE '%', sql;
EXECUTE sql;
IF "ForDetail" THEN
RETURN;
end if;
-- Create INSERT function
sql := '
DROP FUNCTION IF EXISTS zzglc.' || tableapi_name || '_c;
CREATE OR REPLACE FUNCTION zzglc.' || tableapi_name || '_c ("Json" varchar)
RETURNS ' || pk_type || ' AS $F$
DECLARE v_id ' || pk_type || ';
DECLARE json_data json;
BEGIN
json_data := "Json";
INSERT INTO ' || "SchemaName" || '.' || "TableName" || ' (' || column_list || ')
VALUES (' || column_value_list || ')
RETURNING id INTO v_id;
RETURN v_id;
END $F$ LANGUAGE plpgsql;';
--RAISE NOTICE '%', sql;
EXECUTE sql;
IF "ForIsA" THEN
isASql := 'IF NOT FOUND THEN
INSERT INTO ' || "SchemaName" || '.' || "TableName" || ' (' || column_list || ')
VALUES (' || column_value_list || ')
RETURNING id INTO v_id;
END IF;';
END IF;
-- Create UPDATE function
sql := '
DROP FUNCTION IF EXISTS zzglc.' || tableapi_name || '_u;
CREATE OR REPLACE FUNCTION zzglc.' || tableapi_name || '_u ("Json" varchar)
RETURNS ' || pk_type || ' AS $F$
DECLARE v_id ' || pk_type || ';
DECLARE json_data json;
BEGIN
json_data := "Json";
v_id := (json_data->>' || QUOTE_LITERAL(pk_column) || ')::' || pk_type || ';
UPDATE ' || "SchemaName" || '.' || "TableName" || ' SET' || update_list || '
WHERE ' || pk_column || ' = v_id;
' || isASql || '
RETURN v_id;
END $F$ LANGUAGE plpgsql;';
RAISE NOTICE '%', sql;
EXECUTE sql;
-- Create DELETE function
sql := '
DROP FUNCTION IF EXISTS zzglc.' || tableapi_name || '_d("Key" integer);
CREATE OR REPLACE FUNCTION zzglc.' || tableapi_name || '_d
( "Key" ' || pk_type || ')
RETURNS VOID AS $F$
BEGIN
DELETE FROM ' || "SchemaName" || '.' || "TableName" || ' WHERE ' || pk_column || ' = "Key";
END;
$F$ LANGUAGE plpgsql;';
EXECUTE sql;
IF NOT EXISTS(SELECT 1 FROM meta.route r WHERE r.path = '/' || "TableName") THEN
INSERT INTO meta.route (name, order_no, path, component, icon, parent, props, offline, public, active)
VALUES (meta.snake_to_sentence("TableName") || 's', 99999, '/' || "TableName", 'table', 'table_chart', NULL, format('{ "tableAPI" : "%s_%s" }',"SchemaName", "TableName")::json, false, false, true) ;
END IF;
-- generate colAtts
select
json_build_object('colAtts',
jsonb_object_agg (column_name, jsonb_build_object('default' , default_value, 'required', not allow_dbnull ))) INTO v_colatts
FROM x
WHERE column_name != 'id' and (default_value IS NOT NULL or allow_dbnull = false);
IF EXISTS (SELECT 1 FROM meta.tableapi_props WHERE tableapi = tableapi_name) THEN
UPDATE meta.tableapi_props SET colatts = v_colatts WHERE tableapi = tableapi_name;
ELSE
INSERT INTO meta.tableapi_props (tableapi, colatts) VALUES (tableapi_name, v_colatts);
END IF;
END $function$
*/
}
/**
* @function decrypt_varchar
* @memberof meta
* @description Decrypt varchar
* @param {character_varying} value
* @returns {character_varying}
*/
function decrypt_varchar() {
/*
CREATE OR REPLACE FUNCTION meta.decrypt_varchar(value character varying)
RETURNS character varying
LANGUAGE plpgsql
AS $function$
BEGIN
RETURN convert_from(
decrypt(
decode(value, 'hex'), -- Decode the hex-encoded encrypted data
meta.get_key(),
'aes'
),
'UTF8' -- Convert the decrypted bytea back to a UTF-8 string
);
END;
$function$
*/
}
/**
* @function encrypt_varchar
* @memberof meta
* @description Encrypt varchar
* @param {character_varying} value
* @returns {character_varying}
*/
function encrypt_varchar() {
/*
CREATE OR REPLACE FUNCTION meta.encrypt_varchar(value character varying)
RETURNS character varying
LANGUAGE plpgsql
AS $function$
BEGIN
RETURN encode(encrypt(convert_to(value, 'UTF8'), meta.get_key(), 'aes'), 'HEX');
END;
$function$
*/
}
/**
* @function function_exists
* @memberof meta
* @description Checks if a function exists
* @param {character_varying} schema_name
* @param {character_varying} func_name
* @returns {boolean}
*/
function function_exists() {
/*
CREATE OR REPLACE FUNCTION meta.function_exists(schema_name character varying, func_name character varying)
RETURNS boolean
LANGUAGE plpgsql
AS $function$
DECLARE
result BOOLEAN;
BEGIN
SELECT EXISTS (
SELECT 1
FROM pg_proc
JOIN pg_namespace ns ON pg_proc.pronamespace = ns.oid
WHERE ns.nspname = schema_name
AND proname = func_name
) INTO result;
RETURN result;
END;
$function$
*/
}
/**
* @function get_db_procedures
* @memberof meta
* @description Get procedures from the database for documentation generation
* @param {character_varying} SchemaName
* @param {character_varying} ProcName
* @returns {json}
*/
function get_db_procedures() {
/*
CREATE OR REPLACE FUNCTION meta.get_db_procedures("SchemaName" character varying, "ProcName" character varying)
RETURNS json
LANGUAGE plpgsql
AS $function$
BEGIN
RETURN (
WITH t AS (
SELECT
n.nspname,
p.proname,
pg_get_functiondef(p.oid) AS function_definition,
s.description proc_comment,
a.order_no::INT,
a.param_name,
pg_catalog.format_type(COALESCE (b.param_type, d.param_type), null) AS data_type,
c.input_output,
pg_catalog.format_type(p.prorettype, null) AS return_type
FROM pg_proc p
INNER JOIN pg_namespace n ON (p.pronamespace = n.oid)
LEFT JOIN pg_description s ON s.objoid = p.oid
LEFT JOIN unnest(proargnames) WITH ORDINALITY AS a(param_name, order_no) ON true
LEFT JOIN unnest(proargtypes) WITH ORDINALITY AS b(param_type, bseq) ON a.order_no = b.bseq
LEFT JOIN unnest(proargmodes) WITH ORDINALITY AS c(input_output, cseq) ON a.order_no = c.cseq
LEFT JOIN unnest(proallargtypes) WITH ORDINALITY AS d(param_type, dseq) ON a.order_no = d.dseq
WHERE
(n.nspname = "SchemaName" AND p.proname = "ProcName")
OR ("ProcName" IS NULL AND
n.nspname in ('auth', 'catalog', 'data', 'general', 'log', 'meta', 'osm', 'utils', 'zzglc', 'zzgll', 'zzhistory'))
),
b AS (
SELECT nspname, proname, return_type, function_definition, proc_comment,
json_build_object('param_name', param_name, 'data_type', data_type, 'input_output', input_output) param
FROM t
),
c AS (
SELECT nspname proc_schema, proname proc_name, return_type, function_definition, proc_comment,
json_agg(param) params
FROM b
GROUP BY nspname, proname, return_type, function_definition, proc_comment
ORDER BY nspname, proname
)
SELECT json_agg (c.*) FROM c
);
END $function$
*/
}
/**
* @function get_db_schema
* @memberof meta
* @description Get schema of database for documentation generation
* @returns {json}
*/
function get_db_schema() {
/*
CREATE OR REPLACE FUNCTION meta.get_db_schema()
RETURNS json
LANGUAGE plpgsql
AS $function$
DECLARE v_schema VARCHAR;
DECLARE v_table VARCHAR;
DECLARE j_schemas JSON;
DECLARE j_tables JSON;
BEGIN
SELECT json_agg(t.*) INTO j_schemas FROM (
SELECT nsp.nspname AS schema_name, d.description
FROM pg_catalog.pg_namespace nsp
LEFT JOIN pg_catalog.pg_description d ON d.objoid = nsp.oid
WHERE nsp.nspname IN ('auth', 'catalog', 'data', 'general', 'log', 'meta', 'osm', 'utils', 'zzglc', 'zzgll', 'zzhistory')
) t;
DROP TABLE IF EXISTS tmp;
CREATE TEMP TABLE tmp AS
SELECT * FROM meta.get_table_cols('auth', 'log');
DELETE FROM tmp;
FOR v_schema, v_table IN
SELECT table_schema, table_name
FROM information_schema.tables
WHERE table_catalog = 'ai4soilhealth' and table_schema in ('auth', 'catalog', 'data', 'general', 'log', 'meta', 'osm', 'utils', 'zzglc', 'zzgll', 'zzhistory')
LOOP
INSERT INTO tmp
SELECT * FROM meta.get_table_cols(v_schema, v_table);
END LOOP;
WITH
a AS (
SELECT table_schema, table_name,
json_build_object('column_name', column_name, 'data_type', data_type, 'column_comment', column_comment, 'referenced_schema_name', referenced_schema_name, 'referenced_table_name', referenced_table_name, 'referenced_column_name', referenced_column_name) column
FROM (
SELECT t.*, ac.description column_comment
FROM tmp t
LEFT JOIN pg_attribute a
ON a.attrelid = (table_schema || '.' || table_name)::regclass AND a.attname = t.column_name
LEFT JOIN pg_description ac
ON ac.objoid = a.attrelid and ac.objsubid = a.attnum
) t
),
b AS (
SELECT a.table_schema, a.table_name, tc.description table_comment, json_agg(a.column) columns
FROM a
LEFT JOIN pg_description tc
ON tc.objoid = (table_schema || '.' || table_name)::regclass and tc.objsubid = 0
GROUP BY a.table_schema, a.table_name, tc.description
ORDER BY 1, 2
)
SELECT json_agg(c.*) INTO j_tables FROM (
SELECT * FROM b
ORDER BY table_schema, table_name
) c;
RETURN json_build_object('schemas', j_schemas, 'tables', j_tables);
END
$function$
*/
}
/**
* @function get_for_translate
* @memberof meta
* @property {integer} "Id"
* @property {character_varying} TableName
* @property {character_varying} ParentKeyName
* @returns {character_varying}
*/
function get_for_translate() {
/*
CREATE OR REPLACE FUNCTION meta.get_for_translate("Id" integer, "TableName" character varying, "ParentKeyName" character varying)
RETURNS character varying
LANGUAGE plpgsql
AS $function$
DECLARE v_sql text;
DECLARE v_result text;
BEGIN
v_sql := format ('SELECT coalesce(t.value, i.key) FROM %s i LEFT JOIN %s_lang t ON t.lang_id = 1 AND t.%s = i.id WHERE i.id = %s', "TableName", "TableName", "ParentKeyName", "Id");
EXECUTE v_sql INTO v_result;
RETURN v_result;
END
$function$
*/
}
/**
* @function get_help
* @memberof meta
* @description Get help for a given topic in a given language
* @param {character_varying} Name
* @param {integer} LangId
* @returns {json}
*/
function get_help() {
/*
CREATE OR REPLACE FUNCTION meta.get_help("Name" character varying, "LangId" integer)
RETURNS json
LANGUAGE plpgsql
AS $function$
BEGIN
RETURN (
SELECT json_build_object('help', COALESCE(l.value, e.value) )
FROM meta.help h
LEFT JOIN meta.help_lang l ON l.lang_id = "LangId" AND l.help_id = h.id
LEFT JOIN meta.help_lang e ON e.lang_id = 1 AND e.help_id = h.id
WHERE h.name = "Name"
);
END$function$
*/
}
/**
* @function get_i18n
* @memberof meta
* @description Get i18n translation of i18n items in the app for the given language
* @param {integer} LangId
* @returns {json}
*/
function get_i18n() {
/*
CREATE OR REPLACE FUNCTION meta.get_i18n("LangId" integer)
RETURNS json
LANGUAGE plpgsql
AS $function$
BEGIN
-- Routine body goes here...
RETURN (
-- SELECT json_agg(json_build_object(i.key, l.value))
SELECT json_object_agg(i.key, l.value)
FROM meta.i18n i
INNER JOIN meta.i18n_lang l ON l.i18n_id = i.id and l.lang_id = "LangId"
);
END$function$
*/
}
/**
* @function get_key
* @memberof meta
* @description Get key
* @returns {bytea}
*/
function get_key() {
/*
CREATE OR REPLACE FUNCTION meta.get_key()
RETURNS bytea
LANGUAGE plpgsql
AS $function$
BEGIN
RETURN '!ag#v$e%t%+&qG7p$2xY!9w#F@zV&4mQ';
END;
$function$
*/
}
/**
* @function get_lang
* @memberof meta
* @description Get languages fro locale selection for admin auxiliary app
* @param {character_varying} SearchValue
* @param {integer} Key
* @returns {Object}
* @property {integer} id
* @property {character_varying} name
* @property {character_varying} short_tag
*/
function get_lang() {
/*
CREATE OR REPLACE FUNCTION meta.get_lang("SearchValue" character varying, "Key" integer)
RETURNS TABLE(id integer, name character varying, short_tag character varying)
LANGUAGE plpgsql
AS $function$
BEGIN
-- Routine body goes here...
RETURN QUERY
SELECT l.id, l.name, l.short_tag::VARCHAR
FROM meta.lang l
WHERE l.name like "SearchValue"
ORDER BY l.name;
END
$function$
*/
}
/**
* @function get_locale_options
* @memberof meta
* @description Get locale options for language selection in app
* @returns {json}
*/
function get_locale_options() {
/*
CREATE OR REPLACE FUNCTION meta.get_locale_options()
RETURNS json
LANGUAGE plpgsql
AS $function$
BEGIN
-- Routine body goes here...
RETURN (
SELECT json_agg(t.*)
FROM (
SELECT tag "value", name "label", id, short_tag
FROM meta.lang ORDER BY name
) t
);
END$function$
*/
}
/**
* @function get_news
* @memberof meta
* @description Get news
* @param {integer} LangId
* @returns {Object}
* @property {integer} id
* @property {character_varying} title
* @property {character_varying} text
* @property {character_varying} extended_text
* @property {timestamp_without_time_zone} time_modified
* @property {timestamp_without_time_zone} time_created
* @property {character_varying} user_modified
*/
function get_news() {
/*
CREATE OR REPLACE FUNCTION meta.get_news("LangId" integer)
RETURNS TABLE(id integer, title character varying, text character varying, extended_text character varying, time_modified timestamp with time zone, time_created timestamp with time zone, user_modified character varying)
LANGUAGE plpgsql
AS $function$
DECLARE v_person_id integer;
BEGIN
IF auth.get_context_person_id() is null THEN
v_person_id := NULL;
ELSE
v_person_id := auth.get_context_person_id();
END IF;
RETURN QUERY
SELECT DISTINCT n.id,
COALESCE(l.title, e.title) title,
COALESCE(l.text, e.text) text,
COALESCE(l.extended_text, e.extended_text) extended_text,
COALESCE(l.time_modified, e.time_modified) time_modified,
COALESCE(l.time_created, e.time_created) time_created,
NULL::varchar --(p.last_name || p.first_name)::VARCHAR
FROM meta.news n
LEFT JOIN meta.news_lang l ON l.news_id = n.id and l.lang_id = "LangId"
LEFT JOIN meta.news_lang e ON e.news_id = n.id and e.lang_id = 1
LEFT JOIN auth.news_role r ON n.id = r.news_id
LEFT JOIN auth.person_role u ON r.role_id = u.role_id AND u.person_id = v_person_id
WHERE n.active = true AND (r.id is null OR u.id is not null OR auth.get_context_is_admin())
ORDER BY time_modified DESC;
END$function$
*/
}
/**
* @function get_policy
* @memberof meta
* @description Get policy
* @param {character_varying} PolicyType
* @returns {text}
*/
function get_policy() {
/*
CREATE OR REPLACE FUNCTION meta.get_policy("PolicyType" character varying)
RETURNS text
LANGUAGE plpgsql
AS $function$
BEGIN
IF "PolicyType" = 'privacy' THEN
RETURN (SELECT privacy_policy FROM meta.app);
ELSE
RETURN (SELECT terms_of_service FROM meta.app);
END IF;
END $function$
*/
}
/**
* @function get_routes
* @memberof meta
* @description Get routes (menu items with properties) for a person in a language
* @param {integer} PersonId
* @param {integer} LangId
* @returns {json}
*/
function get_routes() {
/*
CREATE OR REPLACE FUNCTION meta.get_routes("PersonId" integer, "LangId" integer)
RETURNS json
LANGUAGE plpgsql
AS $function$
BEGIN
-- Routine body goes here...
RETURN (
WITH cte AS (
SELECT r.id, MIN(rrp.read_only::INT) read_only FROM meta.route r
LEFT JOIN auth.person_role prp ON prp.person_id = "PersonId"
LEFT JOIN auth.route_role rrp ON rrp.route_id = r.id AND rrp.role_id = prp.role_id
LEFT JOIN auth.person_role arp ON arp.person_id = "PersonId" AND arp.role_id = 1
WHERE r.active
AND (r."public"
OR arp.id IS NOT NULL -- user is admin
-- OR (rrp.id is null and "PersonId" is not null) -- no role assigned
OR (rrp.id is not null and rrp.role_id = prp.role_id)) -- role assigned and matched
GROUP BY r.id
)
SELECT json_agg(t.*)
FROM (
SELECT r.order_no, r.name, r.path, r.component,
COALESCE (r.value, r.name) title, r.icon, r.parent, r.props, r.offline, r.public, r.active, r.id, r.read_only, r.locked
FROM (
SELECT r.order_no, r.name, r.path, r.component, r.offline, r.public, r.props,
l.value, r.icon, r.parent, r.active, r.id, cte.read_only::boolean, r.locked, r.title
FROM cte
INNER JOIN meta.route r ON r.id = cte.id
LEFT JOIN meta.i18n i ON i.key = r.name
LEFT JOIN meta.i18n_lang l ON l.i18n_id = i.id and l.lang_id = "LangId"
) r
ORDER BY r.parent, r.order_no
) t
);
END$function$
*/
}
/**
* @function get_schema_name
* @memberof meta
* @description Get schema name for the given table
* @param {text} TableName
* @returns {text}
*/
function get_schema_name() {
/*
CREATE OR REPLACE FUNCTION meta.get_schema_name("TableName" text)
RETURNS text
LANGUAGE plpgsql
AS $function$
DECLARE
schema_name text;
BEGIN
-- Retrieve the schema name for the given table
SELECT nspname INTO schema_name
FROM pg_class c
JOIN pg_namespace n ON c.relnamespace = n.oid
WHERE c.relname = "TableName"
LIMIT 1;
RETURN schema_name;
END;
$function$
*/
}
/**
* @function get_schemas
* @memberof meta
* @description Get schemas
* @returns {Object} character_varying schema_namecharacter_varying table_name
*/
function get_schemas() {
/*
CREATE OR REPLACE FUNCTION meta.get_schemas()
RETURNS TABLE(schema_name character varying, table_name character varying)
LANGUAGE plpgsql
AS $function$
BEGIN
RETURN QUERY (SELECT schemaname::varchar, tablename::varchar
FROM pg_tables
WHERE schemaname not in ('pg_catalog', 'information_schema')
AND schemaname NOT LIKE 'zz%'
ORDER BY schemaname, tablename);
END $function$
*/
}
/**
* @function get_table_cols
* @memberof meta
* @description Get table columns and foreign keys for crud generation
* @param {character_varying} SchemaName
* @param {character_varying} TableName
* @returns {Object}
* @property {character_varying} table_schema
* @property {character_varying} table_name
* @property {character_varying} column_name
* @property {character_varying} referenced_schema_name
* @property {character_varying} referenced_table_name
* @property {character_varying} referenced_column_name
* @property {character_varying} data_type
* @property {character_varying} data_type_full
* @property {integer} ordinal_number
* @property {integer} max_length
* @property {integer} numeric_precision
* @property {integer} numeric_scale
* @property {boolean} is_identity
* @property {boolean} is_fk
* @property {boolean} is_computed
* @property {character_varying} default_value
* @property {character_varying} referenced_display_column_name
* @property {boolean} allow_dbnull
* @property {boolean} referenced_column_language_dependent
*/
function get_table_cols() {
/*
CREATE OR REPLACE FUNCTION meta.get_table_cols("SchemaName" character varying, "TableName" character varying)
RETURNS TABLE(table_schema character varying, table_name character varying, column_name character varying, referenced_schema_name character varying, referenced_table_name character varying, referenced_column_name character varying, data_type character varying, data_type_full character varying, ordinal_number integer, max_length integer, numeric_precision integer, numeric_scale integer, is_identity boolean, is_fk boolean, is_computed boolean, default_value character varying, referenced_display_column_name character varying, allow_dbnull boolean, referenced_column_language_dependent boolean)
LANGUAGE plpgsql
AS $function$
BEGIN
BEGIN
DROP TABLE IF EXISTS t;
CREATE TEMP TABLE t AS
SELECT
"SchemaName" AS table_schema,
"TableName" AS table_name,
a.attname AS column_name,
n.nspname AS referenced_schema_name,
t.relname::VARCHAR AS referenced_table_name,
af.attname AS referenced_column_name
FROM
pg_constraint c
JOIN pg_attribute a ON c.conrelid = a.attrelid AND a.attnum = c.conkey[1]
JOIN pg_attribute af ON c.confrelid = af.attrelid AND af.attnum = c.confkey[1]
JOIN pg_class t ON t.oid = c.confrelid
JOIN pg_namespace n ON n.oid = t.relnamespace
WHERE c.contype = 'f'
AND c.conrelid = ("SchemaName" || '.' || "TableName")::regclass;
RETURN QUERY
SELECT
"SchemaName" AS table_schema,
"TableName" AS table_name,
a.attname::VARCHAR column_name,
t.referenced_schema_name::VARCHAR,
--COALESCE(l.relname, t.referenced_table_name)::VARCHAR referenced_table_name,
--COALESCE(rcl.attname,t.referenced_column_name)::VARCHAR referenced_column_name,
t.referenced_table_name::VARCHAR,
t.referenced_column_name::VARCHAR,
format_type(a.atttypid, null)::VARCHAR data_type,
format_type(a.atttypid, a.atttypmod)::VARCHAR data_type_full,
a.attnum::INT ordinal_number,
a.attlen::INT max_lengthT,
((a.atttypmod - 4) & 65535)::INT numeric_precision,
null::INT numeric_scale,
(a.attidentity != '' OR a.attnum = 1 AND a.atthasdef)::BOOLEAN is_identity,
(t.referenced_column_name IS NOT NULL)::BOOLEAN is_fk,
(a.attgenerated != '')::BOOLEAN is_computed,
pg_get_expr(d.adbin, d.adrelid)::VARCHAR default_value,
--COALESCE(rc.ref_col, rl.attname, r.attname)::VARCHAR referenced_display_columnName,
COALESCE(rc.ref_col, r.attname)::VARCHAR referenced_display_columnName,
(NOT a.attnotnull)::BOOLEAN allow_db_null,
--(l.relname IS NOT NULL)::BOOLEAN referenced_column_language_dependent
false referenced_column_language_dependent
FROM pg_attribute a
LEFT JOIN t
ON t.column_name = a.attname
LEFT JOIN pg_attrdef d
ON a.attrelid = d.adrelid AND a.attnum = d.adnum
LEFT JOIN pg_attribute r
ON r.attrelid = (t.referenced_schema_name || '.' || t.referenced_table_name)::regclass AND r.attnum = 2 AND NOT r.attisdropped
-- LEFT JOIN pg_statio_user_tables l
-- ON l.schemaname = t.referenced_schema_name
-- AND l.relname = t.referenced_table_name || '_lang'
-- AND "TableName" NOT LIKE '%_lang'
-- LEFT JOIN pg_attribute rl
-- ON rl.attrelid = l.relid AND rl.attnum = 4 AND NOT rl.attisdropped
-- LEFT JOIN pg_attribute rcl
-- ON rcl.attrelid = l.relid AND rcl.attnum = 2 AND NOT rcl.attisdropped
LEFT JOIN meta.table_ref_col rc ON rc.schema_name = t.referenced_schema_name AND rc.table_name = t.referenced_table_name
WHERE a.attrelid = ("SchemaName" || '.' || "TableName")::regclass
AND NOT a.attisdropped
AND a.attnum > 0
ORDER BY a.attnum;
EXCEPTION
WHEN undefined_table THEN
RAISE NOTICE '%', 'EXCEPTION';
END;
END $function$
*/
}
/**
* @function get_tableapi_props
* @memberof meta
* @description Get tableapi props
* @param {character_varying} TableAPI
* @returns {json}
*/
function get_tableapi_props() {
/*
CREATE OR REPLACE FUNCTION meta.get_tableapi_props("TableAPI" character varying)
RETURNS json
LANGUAGE plpgsql
AS $function$
BEGIN
RETURN (SELECT json_build_object ('props', COALESCE(props, '{}'::json), 'colAtts', COALESCE(colatts, '{}'::json)) FROM meta.tableapi_props WHERE tableapi= "TableAPI");
END $function$
*/
}
/**
* @function i18n_itrig_proc
* @memberof meta
* @description I18n itrig procedure - adds a new i18n key to the i18n_lang table for each language in the lang table
* @returns {trigger}
*/
function i18n_itrig_proc() {
/*
CREATE OR REPLACE FUNCTION meta.i18n_itrig_proc()
RETURNS trigger
LANGUAGE plpgsql
AS $function$
BEGIN
INSERT INTO meta.i18n_lang (i18n_id, lang_id, value)
SELECT NEW.id, l.id, NEW.key
FROM meta.lang l
LEFT JOIN meta.i18n_lang i ON i.lang_id = l.id AND i.i18n_id = NEW.id
WHERE i.id IS NULL;
RETURN NEW;
END$function$
*/
}
/**
* @function import_detail_clone
* @memberof meta
* @description Clone procedure for import_detail table
* @param {character_varying} Id
* @returns {void}
*/
function import_detail_clone() {
/*
CREATE OR REPLACE FUNCTION meta.import_detail_clone("Id" character varying)
RETURNS void
LANGUAGE plpgsql
AS $function$
DECLARE v_new_id INT;
BEGIN
-- Routine body goes here...
INSERT INTO meta.import_detail (import_master_id, col_name, target_schema, target_table, target_column, col_type, is_key, is_fk, as_row, target_column_list, source_column_list, joins, split, ignore)
SELECT import_master_id, col_name || '_cloned', target_schema, target_table, target_column, col_type, is_key, is_fk, as_row, target_column_list, source_column_list, joins, split, ignore
FROM meta.import_detail
WHERE id = "Id"::int
RETURNING id INTO v_new_id;
RETURN;
END$function$
*/
}
/**
* @function import_master_clone
* @memberof meta
* @description Clone provided import_master and all associated import_detail records
* @param {character_varying} Id
* @returns {void}
*/
function import_master_clone() {
/*
CREATE OR REPLACE FUNCTION meta.import_master_clone("Id" integer)
RETURNS void
LANGUAGE plpgsql
AS $function$
DECLARE v_new_id INT;
BEGIN
-- Routine body goes here...
INSERT INTO meta.import_master (schema_name, table_name, file_name, sheet, import_name)
SELECT schema_name, table_name, file_name, sheet, import_name || '_cloned'
FROM meta.import_master
WHERE id = "Id"
RETURNING id INTO v_new_id;
INSERT INTO meta.import_detail (import_master_id, col_name, target_schema, target_table, target_column, col_type, is_key, is_fk, as_row, target_column_list, source_column_list, joins, split, ignore)
SELECT v_new_id, col_name, target_schema, target_table, target_column, col_type, is_key, is_fk, as_row, target_column_list, source_column_list, joins, split, ignore
FROM meta.import_detail
WHERE import_master_id = "Id";
RETURN;
END$function$
*/
}
/**
* @function import_proc_from_gl
* @memberof meta
* @description Import procedure with given schema and procedure name with its definition from gl schema
* @param {character_varying} SchemaName
* @param {character_varying} ProcName
* @returns {void}
*/
function import_proc_from_gl() {
/*
CREATE OR REPLACE PROCEDURE meta.import_proc_from_gl(IN "SchemaName" character varying, IN "ProcName" character varying)
LANGUAGE plpgsql
AS $procedure$
DECLARE sql VARCHAR;
BEGIN
select definition --|| ' language ' || function_language
INTO sql
from zzz_pg_catalog_gl.vwproc v
where v.function_schema = "SchemaName"
AND v.function_name = "ProcName";
raise notice '%', sql;
EXECUTE sql;
END $procedure$
*/
}
/**
* @function is_function_safe
* @memberof meta
* @description Returns if a function is safe to execute
* @param {character_varying} Function
* @returns {boolean}
*/
function is_function_safe() {
/*
CREATE OR REPLACE FUNCTION meta.is_function_safe("Function" character varying)
RETURNS boolean
LANGUAGE plpgsql
AS $function$
BEGIN
IF EXISTS (SELECT 1 FROM meta.safe_function WHERE name = "Function") THEN
RETURN true;
ELSE
RETURN false;
END IF;
END $function$
*/
}
/**
* @function list_procedures
* @memberof meta
* @description List procedures
* @param {text} Params
* @param {integer} PersonId
* @param {integer} LangId
* @returns {json}
*/
function list_procedures() {
/*
CREATE OR REPLACE FUNCTION meta.list_procedures("Params" text, "PersonId" integer, "LangId" integer)
RETURNS json
LANGUAGE plpgsql
AS $function$
BEGIN
RETURN (SELECT json_agg(t.*) FROM (
SELECT
n.nspname AS schema_name,
proname AS procedure_name,
pg_catalog.pg_get_function_result(p.oid) AS return_type,
pg_catalog.pg_get_function_arguments(p.oid) AS arguments
FROM pg_proc p
JOIN pg_namespace n ON n.oid = p.pronamespace
WHERE n.nspname NOT IN ('pg_catalog', 'information_schema')
ORDER BY schema_name, procedure_name
) t);
END $function$
*/
}
/**
* @function list_tables
* @memberof meta
* @description List tables
* @param {text} Params
* @param {integer} PersonId
* @param {integer} LangId
* @returns {Object} bigint idboolean for_detailcharacter_varying master_keyboolean for_isaboolean with_ownershipcharacter_varying table_schemacharacter_varying table_name
*/
function list_tables() {
/*
CREATE OR REPLACE FUNCTION meta.list_tables("Params" text, "PersonId" integer, "LangId" integer)
RETURNS TABLE(id bigint, for_detail boolean, master_key character varying, for_isa boolean, with_ownership boolean, table_schema character varying, table_name character varying)
LANGUAGE plpgsql
AS $function$
DECLARE db VARCHAR;
DECLARE sql VARCHAR;
BEGIN
RETURN QUERY (
SELECT DISTINCT
row_number() over (ORDER BY schemaname, tablename) id,
false AS for_detail,
''::varchar AS master_key,
false AS for_isa,
false AS with_ownership,
CAST(t.schemaname AS VARCHAR),
CAST(t.tablename AS VARCHAR)
FROM pg_tables AS t
WHERE t.schemaname NOT IN ('pg_catalog', 'information_schema')
ORDER BY 5, 6
);
END $function$
*/
}
/**
* @function lookup
* @memberof meta
* @description Create lookup procedure for a table
* @param {character_varying} "SchemaName"
* @param {character_varying} "TableName"
* @param {character_varying} "ReferencedColumnDisplayName"
* @param {character_varying} "ReferencedColumnType"
* @returns {void}
*/
function lookup() {
/*
CREATE OR REPLACE FUNCTION meta.lookup("SchemaName" character varying, "TableName" character varying, "ReferencedColumnDisplayName" character varying, "ReferencedColumnType" character varying)
RETURNS void
LANGUAGE plpgsql
AS $function$
DECLARE sql VARCHAR;
BEGIN
IF meta.function_exists('zzgll'::varchar, ("SchemaName" || '_' || "TableName" || '_l')::varchar) THEN
RETURN;
END IF;
sql := 'DROP FUNCTION IF EXISTS zzgll.' || "SchemaName" || '_' || "TableName" || '_l;
CREATE OR REPLACE FUNCTION zzgll.' || "SchemaName" || '_' || "TableName" || '_l("SearchValue" varchar, "Key" ' || "ReferencedColumnType" || '=NULL::' || "ReferencedColumnType" || ')
RETURNS TABLE(id ' || "ReferencedColumnType" || ', ' || "ReferencedColumnDisplayName" || ' varchar) AS $f$
BEGIN
IF "Key" IS NOT NULL THEN
RETURN QUERY
SELECT t.id, t.' || "ReferencedColumnDisplayName" || '
FROM ' || "SchemaName" || '.' || "TableName" || ' t
WHERE t.id = "Key"::' || "ReferencedColumnType" || ';
ELSE
RETURN QUERY
SELECT t.id, t.' || "ReferencedColumnDisplayName" || '
FROM ' || "SchemaName" || '.' || "TableName" || ' t
WHERE t.' || "ReferencedColumnDisplayName" || ' LIKE "SearchValue"
ORDER BY t.' || "ReferencedColumnDisplayName" || '
LIMIT 1000;
END IF;
END $f$
LANGUAGE plpgsql ';
--RAISE NOTICE '%', sql;
EXECUTE sql;
END $function$
*/
}
/**
* @function meta_route_clone
* @memberof meta
* @description Meta route clone
* @param {integer} Id
* @returns {integer}
*/
function meta_route_clone() {
/*
CREATE OR REPLACE FUNCTION meta.meta_route_clone("Id" integer)
RETURNS integer
LANGUAGE plpgsql
AS $function$
DECLARE v_id INT;
BEGIN
INSERT INTO meta.route (name, order_no, path, component, icon, parent, props, public, active, offline)
SELECT name || ' cloned', order_no, path || 'cloned', component, icon, parent, props, public, active, offline
FROM meta.route
WHERE id = "Id"
RETURNING id INTO v_id;
RETURN v_id;
END$function$
*/
}
/**
* @function prepare_import_proc
* @memberof meta
* @description Prepare import procedure for a given import master id
* @param {integer} Id
* @returns {void}
*/
function prepare_import_proc() {
/*
CREATE OR REPLACE FUNCTION meta.prepare_import_proc("Id" integer)
RETURNS void
LANGUAGE plpgsql
AS $function$
DECLARE v_sql TEXT;
v_subsql TEXT;
v_master VARCHAR;
v_master_table VARCHAR;
v_master_schema VARCHAR;
v_detail VARCHAR;
v_fragment VARCHAR;
v_schema VARCHAR;
v_table VARCHAR;
v_key_source VARCHAR;
v_key_target VARCHAR;
v_key_type VARCHAR;
v_read_list VARCHAR;
v_source_list VARCHAR;
v_target_list VARCHAR;
v_dummy VARCHAR;
v_target_column_list VARCHAR;
v_source_column_list VARCHAR;
v_joins VARCHAR;
v_col_name VARCHAR;
v_col_type VARCHAR;
v_clean_name VARCHAR;
v_split BOOL;
v_master_key VARCHAR;
v_target_column VARCHAR;
v_target_table VARCHAR;
v_trace VARCHAR;
v_function_name VARCHAR;
v_additional_column_list VARCHAR;
v_additional_joins VARCHAR;
BEGIN
INSERT INTO meta.trace (text) VALUES('prepare_import_proc ' || "Id");
DROP TABLE IF EXISTS t;
CREATE TEMP TABLE t AS
SELECT m.schema_name, m.table_name, d.col_name, d.target_schema, d.target_table, d.target_column, d.col_type, d.target_schema || '.' || d.target_table name, d.is_fk, d.is_key, d.as_row, d.target_column_list, d.source_column_list, d.joins, d.split, d.ignore, d.ignore_in_master, d.constant_value, d.from_additional_join
FROM meta.import_master m
INNER JOIN meta.import_detail d ON d.import_master_id = m.id
WHERE m.id = "Id" -- AND d.target_table > ''
ORDER by d.id;
RAISE NOTICE 't: %', (SELECT COUNT(*) FROM t);
SELECT m.schema_name || '.' || m.table_name, m.table_name, m.schema_name, COALESCE(m.additional_column_list,''), COALESCE(m.additional_joins, '')
INTO v_master, v_master_table, v_master_schema, v_additional_column_list, v_additional_joins
FROM meta.import_master m
WHERE m.id = "Id";
RAISE NOTICE 'master % % %', v_master, v_master_table, v_master_schema;
SELECT col_name INTO v_master_key FROM t WHERE t.is_key AND NOT t.is_fk;
RAISE NOTICE 'master %', v_master;
-- create all detail tables
FOR v_schema, v_table, v_detail IN
SELECT DISTINCT t.target_schema, t.target_table, t.name
FROM t WHERE t.name <> v_master AND NOT t.ignore AND t.as_row = false AND NOT t.split
LOOP
IF NOT EXISTS (SELECT 1 FROM pg_tables WHERE schemaname = v_schema AND tablename = v_table) THEN
SELECT string_agg(t.target_column || ' ' || t.col_type, ', ')
INTO v_fragment
FROM t
WHERE t.target_schema = v_schema AND t.target_table = v_table;
v_sql := E'CREATE TABLE ' || v_detail ||
'(id int primary key generated always as identity, ' || v_fragment || E');\n';
RAISE NOTICE 'detail %', v_sql;
EXECUTE v_sql;
EXECUTE 'ALTER TABLE ' || v_detail || ' OWNER TO gl';
END IF;
END LOOP;
-- create all link tables
FOR v_schema, v_table, v_detail IN
SELECT DISTINCT t.target_schema, t.target_table, t.name
FROM t WHERE t.name <> v_master AND (NOT t.ignore OR t.is_fk) AND t.as_row = false AND t.split
LOOP
RAISE NOTICE '% %', v_schema, v_master_table || '_' || v_table;
IF NOT EXISTS (SELECT 1 FROM pg_tables WHERE schemaname = v_master_schema AND tablename = v_master_table || '_' || v_table) THEN
v_sql := E'CREATE TABLE ' || v_master || '_' || v_table ||
'(id int primary key generated always as identity, ' || v_master_table || '_id int, ' || v_table || '_id int' || E');\n';
RAISE NOTICE '%', v_sql;
EXECUTE v_sql;
EXECUTE 'ALTER TABLE ' || v_master || '_' || v_table || ' OWNER TO gl';
END IF;
END LOOP;
-- create master table
IF NOT EXISTS (SELECT 1 FROM pg_tables WHERE schemaname || '.' || tablename = v_master) THEN
SELECT string_agg(
CASE WHEN t.is_fk THEN
t.target_table || '_id int REFERENCES ' || t.target_schema || '.' || t.target_table || '(id)'
ELSE
t.target_column || ' ' || t.col_type
END
, ', ') INTO v_fragment
FROM t
WHERE NOT t.split AND ((t.name = v_master) OR t.is_fk);
v_sql := E'\nCREATE TABLE ' || v_master ||
'(id int primary key generated always as identity, ' || v_fragment || E');\n';
RAISE NOTICE '%', v_sql;
EXECUTE v_sql;
EXECUTE 'ALTER TABLE ' || v_master || ' OWNER TO gl';
END IF;
--return;
-- create import procedure
SELECT m.schema_name || '.import_' || m.import_name INTO v_function_name
FROM meta.import_master m
WHERE m.id = "Id";
v_function_name := REPLACE(v_function_name, ' ', '_');
IF NOT EXISTS (SELECT 1 FROM meta.safe_function WHERE name = v_function_name) THEN
INSERT INTO meta.safe_function (name) VALUES(v_function_name);
END IF;
RAISE NOTICE 'function name: %', v_function_name;
SELECT string_agg('"' || col_name || '" varchar', ', ')
INTO v_fragment
FROM t WHERE NOT t.from_additional_join;
SELECT
'CREATE OR REPLACE FUNCTION ' || v_function_name ||
E' ("Params" text, "Json" text)\n'
'RETURNS pg_catalog.void AS $$\n'
'BEGIN\n'
'DROP TABLE IF EXISTS q;\n'
'CREATE TEMP TABLE q AS\n'
'SELECT * FROM json_to_recordset("Json"::json) AS J(' || v_fragment || E');\n'
'DROP TABLE IF EXISTS t;\n'
'CREATE TEMP TABLE t AS\n'
'SELECT q.*' || v_additional_column_list || E' FROM q\n' || v_additional_joins || E';\n'
INTO v_sql;
--FROM meta.import_master m
--WHERE m.id = "Id";
IF v_sql IS NULL THEN
RAISE NOTICE 'null 1';
END IF;
-- SELECT json_agg(x.*) INTO v_trace
-- FROM (
-- SELECT DISTINCT CASE WHEN t.name != v_master THEN 'A' ELSE 'B' END, t.target_schema, t.target_table, t.name, t.split, t.target_column
-- FROM t
-- WHERE t.as_row = false and t.target_table > '' ORDER BY 1
-- ) x;
-- RAISE NOTICE '%', v_trace;
-- import tables
FOR v_dummy, v_schema, v_table, v_detail, v_split, v_target_column, v_col_name IN
SELECT DISTINCT CASE WHEN t.name != v_master THEN 'A' ELSE 'B' END, t.target_schema, t.target_table, t.name, t.split, t.target_column, t.col_name
FROM t
WHERE t.as_row = false AND NOT t.ignore AND (t.name != v_master OR t.name = v_master AND t.is_key)
ORDER BY 1
LOOP
RAISE NOTICE 'loop step % % % % %', v_detail, v_dummy, v_schema, v_table, v_split;
-- get key column
SELECT col_name, target_column, col_type INTO v_key_source, v_key_target, v_key_type
FROM t
WHERE NOT t.ignore
AND ((t.name = v_detail AND t.is_key) -- it is a key for foreign table
OR (v_dummy = 'B' AND t.is_key AND t.name = v_master) -- it is main table
);
IF v_split THEN
v_fragment := E'\nCREATE TEMP TABLE temp_' || v_table || E' AS\n'
'SELECT "' || v_master_key || '", TRIM(s) ' || v_col_name || E' FROM t\n'
'CROSS JOIN LATERAL string_to_table("' || v_col_name || '", '','') s';
RAISE NOTICE 'ctt: %', v_fragment;
v_sql := v_sql || v_fragment || E';\n';
IF v_sql IS NULL THEN
RAISE NOTICE 'null 2';
END IF;
END IF;
-- create list for insert
SELECT
string_agg(CASE WHEN t.is_fk AND v_dummy = 'B' THEN t.target_table || '_id' ELSE t.target_column END, ', '),
string_agg('t."' || t.col_name || '"', ', '),
string_agg(
CASE
WHEN t.is_fk AND t.name != v_detail
THEN
t.target_table || '.id'
WHEN t.constant_value IS NOT NULL THEN
t.constant_value
ELSE
'meta.clean_value(x."' || t.col_name || '", ''' || t.col_type || ''')::' || t.col_type
END
, ', ')
INTO v_target_list, v_read_list, v_source_list
FROM t
WHERE t.as_row = false and NOT t.ignore AND
(t.name = v_detail OR v_dummy = 'B' AND NOT t.split AND NOT t.ignore_in_master);
--RAISE NOTICE 'ttt % % %', v_target_list, v_read_list, v_source_list;
v_subsql := E'\nWITH x AS (SELECT DISTINCT ' || v_read_list || ' FROM ' ||
CASE WHEN v_split THEN 'temp_' || v_table ELSE '' END
|| E' t)\n'
'INSERT INTO ' || v_detail || '(';
v_subsql := v_subsql || v_target_list || E')\n'
'SELECT ' || v_source_list || E' FROM x\n'
'LEFT JOIN ' || v_schema || '.' || v_table || ' ' || v_table || ' ON ' || v_table || '.' || v_key_target || '= meta.clean_value( x."' || v_key_source || '", ''' || v_key_type || ''')::' || v_key_type || E'\n';
-- RAISE NOTICE 'xxx v_subsql %', v_subsql;
v_fragment := '';
-- create joins
IF v_detail = v_master THEN
SELECT string_agg(
'LEFT JOIN ' || t.name || ' ' || t.target_table || ' ON ' || t.target_table || '.' || t.target_column || ' = x."' || t.col_name || '"::' || t.col_type, E'\n'
)
INTO v_fragment
FROM t
WHERE t.is_fk AND NOT t.split AND NOT t.ignore AND NOT t.ignore_in_master;
v_fragment = v_fragment || E'\n';
END IF;
--RAISE NOTICE 'xxx % %', v_fragment, v_subsql;
v_subsql := v_subsql || COALESCE(v_fragment, '') || 'WHERE ' || v_table || E'.id IS NULL;\n\n' ;
--RAISE NOTICE 'v_subsql: %', v_subsql;
v_sql := v_sql || v_subsql;
IF v_sql IS NULL THEN
RAISE NOTICE 'null 3';
END IF;
END LOOP;
SELECT col_name, target_column INTO v_key_source, v_key_target FROM t WHERE t.is_key AND t.name = v_master;
-- create insert for link tables
FOR v_target_column, v_target_table, v_detail, v_col_name IN
SELECT t.target_column, t.target_table, t.name, t.col_name FROM t WHERE t.split
LOOP
v_fragment := 'INSERT INTO ' || v_master || '_' || v_target_table || ' (' || v_master_table || '_id, ' || v_target_table || E'_id )\n'
'SELECT m.id, d.id FROM temp_' || v_target_table || E' x\n'
'INNER JOIN ' || v_master || ' m ON m."' || v_key_target || '" = x."' || v_key_source || E'"\n'
'INNER JOIN ' || v_detail || ' d ON d.' || v_target_column || ' = x."' || v_col_name || E'"\n'
'LEFT JOIN ' || v_master || '_' || v_target_table || ' l ON l.' || v_master_table || '_id = m.id AND l.' || v_target_table || E'_id = d.id\n'
'WHERE l.id IS NULL;\n';
RAISE NOTICE 'link insert: %d', v_fragment;
v_sql := v_sql || v_fragment;
IF v_sql IS NULL THEN
RAISE NOTICE 'null 4';
END IF;
END LOOP;
-- create insert for as_row's
FOR v_detail, v_col_name, v_col_type, v_target_column_list, v_source_column_list, v_joins IN
SELECT t.name, t.col_name, t.col_type, t.target_column_list, t.source_column_list, t.joins
FROM t
WHERE t.as_row = true
LOOP
--RAISE NOTICE 'creating % % % % % %' , v_detail, v_col_name, v_col_type, v_target_column_list, v_source_column_list, v_joins;
v_clean_name := 'meta.clean_value(t."' || v_col_name || '", ' || '''' || v_col_type || ''')::' || v_col_type;
v_subsql = E'\nINSERT INTO ' || v_detail || '(' || v_target_column_list || E')\n'
'SELECT ' || REPLACE (v_source_column_list, 'col_name', v_clean_name) || E' FROM t\n'
'LEFT JOIN ' || v_master || ' x ON x.' || v_key_target || ' = t."' || v_key_source || E'"\n'
|| v_joins || E'\nWHERE y.id IS NULL AND ' || v_clean_name || E' IS NOT NULL ;\n';
RAISE NOTICE '%', v_subsql;
v_sql := v_sql || v_subsql;
END LOOP;
v_sql := v_sql || E'\nEND $$ LANGUAGE plpgsql';
-- RAISE NOTICE 'done, executing';
RAISE NOTICE 'Final sql: % %', LENGTH(v_sql), v_sql;
-- RAISE NOTICE 'End final sql:';
DELETE FROM meta.trace;
INSERT INTO meta.trace (text) VALUES(v_sql);
EXECUTE v_sql;
RETURN;
END$function$
*/
}
/**
* @function prepare_joins
* @memberof meta
* @description Prepare joins for import_detail table
* @param {integer} Id
* @returns {void}
*/
function prepare_joins() {
/*
CREATE OR REPLACE FUNCTION meta.prepare_joins("Id" integer)
RETURNS void
LANGUAGE plpgsql
AS $function$
DECLARE
v_data_date VARCHAR;
v_constant_value VARCHAR;
BEGIN
SELECT data_date, constant_value
INTO v_data_date, v_constant_value
FROM meta.import_master WHERE id = "Id";
RAISE NOTICE '%', v_data_date;
IF EXISTS (SELECT 1 FROM meta.import_detail WHERE import_master_id = "Id" AND col_name = 'depth') THEN
UPDATE meta.import_detail t SET
source_column_list = 'x.id, i.id, d.id, col_name, ' || v_data_date || ', ' || v_constant_value,
target_column_list = 'point_id, indicator_id, depth_id, value, date, data_source_id',
joins =
' left join data.indicator i on i.name_match = ''' || t.name_match || '''' ||
' left join data.measurement y on y.point_id = x.id and y.indicator_id = i.id and y.date = ' || v_data_date ||
' left join data.depth d on d.name = t.depth'
WHERE t.target_table = 'measurement' AND t.import_master_id = "Id"; --AND t.source_column_list IS NULL;
ELSE
UPDATE meta.import_detail t SET
source_column_list = 'x.id, i.id, col_name, ' || v_data_date || ', ' || v_constant_value,
target_column_list = 'point_id, indicator_id, value, date, data_source_id',
joins =
' left join data.indicator i on i.name_match = ''' || t.name_match || '''' ||
' left join data.measurement y on y.point_id = x.id and y.indicator_id = i.id and y.date = ' || v_data_date
WHERE t.target_table = 'measurement' AND t.import_master_id = "Id"; --AND t.source_column_list IS NULL;
END IF;
END $function$
*/
}
/**
* @function raise_error
* @memberof meta
* @description Raise a given error
* @param {integer} Code
* @param {character_varying} Explanation
* @returns {void}
*/
function raise_error() {
/*
CREATE OR REPLACE FUNCTION meta.raise_error("Code" integer, "Explanation" character varying DEFAULT ''::character varying)
RETURNS void
LANGUAGE plpgsql
AS $function$
DECLARE
v_lang_id INTEGER;
msg VARCHAR;
BEGIN
v_lang_id := COALESCE (auth.get_context_lang_id (), 1);
SELECT e.message into msg
FROM meta.error AS e
WHERE e.lang_id = v_lang_id
AND e.code = "Code";
IF msg IS NULL THEN
SELECT e.message into msg
FROM meta.error AS e
WHERE e.lang_id = 1
AND e.code = "Code";
END IF;
msg := COALESCE (msg, 'unknown error') || ' ' || "Explanation";
RAISE EXCEPTION '%', msg;
END $function$
*/
}
/**
* @function remove_quotes_from_table
* @memberof meta
* @description Remove quotes from column names for a given table
* @param {character_varying} TableName
* @returns {void}
*/
function remove_quotes_from_table() {
/*
CREATE OR REPLACE FUNCTION meta.remove_quotes_from_table("TableName" character varying)
RETURNS void
LANGUAGE plpgsql
AS $function$
DECLARE
v_column_name text;
v_data_type text;
BEGIN
FOR v_column_name, v_data_type IN
SELECT c.column_name, c.data_type
FROM information_schema.columns c
WHERE c.table_name = "TableName"
LOOP
IF v_data_type IN ('character varying', 'text', 'character') THEN
EXECUTE format('
UPDATE %I
SET %I = TRIM(BOTH ''"\'' FROM %I)',
"TableName",
v_column_name,
v_column_name
);
END IF;
END LOOP;
END;
$function$
*/
}
/**
* @function reorder_menu
* @memberof meta
* @description Reorder menu
* @param {integer} SourceId
* @param {integer} TargetId
* @param {character_varying} Where
* @returns {void}
*/
function reorder_menu() {
/*
CREATE OR REPLACE FUNCTION meta.reorder_menu("SourceId" integer, "TargetId" integer, "Where" character varying)
RETURNS void
LANGUAGE plpgsql
AS $function$
DECLARE v_order_no INTEGER;
v_parent_path VARCHAR;
v_last INTEGER;
v_path VARCHAR;
v_offset INTEGER;
BEGIN
IF "SourceId" = "TargetId" THEN
RETURN;
END IF;
SELECT path, order_no, parent INTO v_path, v_order_no, v_parent_path
FROM meta.route r WHERE id = "TargetId";
IF "Where" = 'on' THEN
SELECT max(order_no) INTO v_last FROM meta.route WHERE parent = v_path;
UPDATE meta.route SET order_no = COALESCE(v_last, 0) + 1, parent = v_path WHERE id = "SourceId";
ELSE
v_offset := CASE WHEN "Where" = 'before' THEN 0 ELSE 1 END;
RAISE NOTICE '% % %', v_parent_path, v_order_no, v_offset;
UPDATE meta.route SET order_no = order_no + 1 WHERE COALESCE(parent, '') = COALESCE(v_parent_path, '') AND order_no >= v_order_no + v_offset;
UPDATE meta.route SET order_no = v_order_no + v_offset, parent = v_parent_path WHERE id = "SourceId";
END IF;
END $function$
*/
}
/**
* @function rmv
* @memberof meta
* @description Refresh materialized views
* @returns {void}
*/
function rmv() {
/*
CREATE OR REPLACE FUNCTION meta.rmv()
RETURNS void
LANGUAGE plpgsql
AS $function$
BEGIN
REFRESH MATERIALIZED VIEW data.vw_data_source_indicator;
REFRESH MATERIALIZED VIEW data.vw_nuts;
END $function$
*/
}
/**
* @function route_itrig_proc
* @memberof meta
* @description Route itrig proc (adds i18n key if not exists)
* @returns {trigger}
*/
function route_itrig_proc() {
/*
CREATE OR REPLACE FUNCTION meta.route_itrig_proc()
RETURNS trigger
LANGUAGE plpgsql
AS $function$
BEGIN
IF NOT EXISTS (
SELECT 1 FROM meta.i18n i WHERE i.key = NEW.name
) THEN
INSERT INTO meta.i18n (key)
VALUES (NEW.name);
END IF;
RETURN NEW;
END$function$
*/
}
/**
* @function route_reorder
* @memberof meta
* @description Reorder procedure for route table
* @param {character_varying} SourceId
* @param {integer} ToIndex
* @returns {void}
*/
function route_reorder() {
/*
CREATE OR REPLACE FUNCTION meta.route_reorder("SourceId" character varying, "ToIndex" integer DEFAULT 0)
RETURNS void
LANGUAGE plpgsql
AS $function$
BEGIN
UPDATE meta.route
SET order_no = "ToIndex"
WHERE id = "SourceId"::INT;
UPDATE meta.route
SET order_no = order_no + 1
WHERE order_no >= "ToIndex"
AND id <> "SourceId"::INT;
WITH cte AS (
SELECT t.id, row_number() over (ORDER BY t.order_no) new_order_no
FROM meta.route t
ORDER BY t.order_no
)
UPDATE meta.route gc
SET order_no = cte.new_order_no
FROM cte
WHERE gc.id = cte.id;
END $function$
*/
}
/**
* @function set_help
* @memberof meta
* @description Set help text for a given topic and language
* @param {character_varying} Name
* @param {integer} LangId
* @param {text} Help
* @returns {void}
*/
function set_help() {
/*
CREATE OR REPLACE FUNCTION meta.set_help("Name" character varying, "LangId" integer, "Help" text)
RETURNS void
LANGUAGE plpgsql
AS $function$
DECLARE v_help_id INT;
DECLARE v_row_count INT;
BEGIN
SELECT id INTO v_help_id FROM meta.help WHERE name = "Name";
IF v_help_id IS NULL THEN
INSERT INTO meta.help (name) VALUES ("Name")
RETURNING id INTO v_help_id;
END IF;
UPDATE meta.help_lang SET value = "Help" WHERE help_id = v_help_id AND lang_id = "LangId";
GET DIAGNOSTICS v_row_count = ROW_COUNT;
IF v_row_count = 0 THEN
INSERT INTO meta.help_lang (help_id, lang_id, value) VALUES (v_help_id, "LangId", "Help");
END IF;
END$function$
*/
}
/**
* @function set_locked
* @memberof meta
* @description Set locked
* @param {integer} Id
* @param {boolean} Locked
* @returns {void}
*/
function set_locked() {
/*
CREATE OR REPLACE FUNCTION meta.set_locked("Id" integer, "Locked" boolean)
RETURNS void
LANGUAGE plpgsql
AS $function$
BEGIN
update meta.route set locked = "Locked" WHERE id = "Id";
END;
$function$
*/
}
/**
* @function set_tableapi_props
* @memberof meta
* @description Set tableapi props
* @param {character_varying} Tableapi
* @param {character_varying} Json
* @returns {void}
*/
function set_tableapi_props() {
/*
CREATE OR REPLACE FUNCTION meta.set_tableapi_props("Tableapi" character varying, "Json" character varying)
RETURNS void
LANGUAGE plpgsql
AS $function$
BEGIN
UPDATE meta.tableapi_props SET colatts = "Json"::json WHERE tableapi = "Tableapi";
IF NOT FOUND THEN
INSERT INTO meta.tableapi_props (tableapi, colatts) VALUES ("Tableapi", "Json"::json);
END IF;
RETURN;
END $function$
*/
}
/**
* @function snake_to_sentence
* @memberof meta
* @description Snake to sentence
* @param {character_varying} s
* @returns {character_varying}
*/
function snake_to_sentence() {
/*
CREATE OR REPLACE FUNCTION meta.snake_to_sentence(s character varying)
RETURNS character varying
LANGUAGE plpgsql
AS $function$
declare r varchar;
begin
r := regexp_replace(s, '_', ' ', 'g');
return upper(left(r,1)) || right(r, length(r)-1);
end
$function$
*/
}
/**
* @function translate
* @memberof meta
* @description Translate a field value in a table to a specific language
* @param {character_varying} Locale
* @param {character_varying} TableName
* @param {character_varying} KeyName
* @param {character_varying} KeyValue
* @param {character_varying} ParentKeyName
* @param {character_varying} ParentKeyValue
* @param {character_varying} FieldName
* @param {character_varying} FieldValue
* @returns {void}
*/
function translate() {
/*
CREATE OR REPLACE FUNCTION meta.translate("Locale" character varying, "TableName" character varying, "KeyName" character varying, "KeyValue" character varying, "ParentKeyName" character varying, "ParentKeyValue" character varying, "FieldName" character varying, "FieldValue" character varying)
RETURNS void
LANGUAGE plpgsql
AS $function$
DECLARE v_sql varchar;
DECLARE v_row_count int;
DECLARE v_lang_id int;
BEGIN
SELECT l.id INTO v_lang_id FROM meta.lang l WHERE l.short_tag = "Locale";
v_sql := format ('UPDATE %s SET %s = ''%s'' WHERE lang_id = %s and %s = %s', "TableName", "FieldName", "FieldValue", v_lang_id, "KeyName", "KeyValue");
EXECUTE v_sql;
GET DIAGNOSTICS v_row_count = ROW_COUNT;
IF v_row_count = 0 THEN
v_sql := format ('INSERT INTO %s(lang_id, %s, %s) VALUES (%s, %s, ''%s'')', "TableName", "ParentKeyName", "FieldName", v_lang_id, "ParentKeyValue", "FieldValue");
EXECUTE v_sql;
END IF;
END
$function$
*/
}
/**
* @function translate
_overload
* @overload translate
* @memberof meta
* @description Translate a field value in a table to a specific language
* @param {character_varying} Locale
* @param {character_varying} TableName
* @param {character_varying} KeyName
* @param {character_varying} KeyValue
* @param {character_varying} ParentKeyName
* @param {character_varying} ParentKeyValue
* @param {character_varying} FieldName
* @param {character_varying} FieldValue
* @returns {void}
*/
function translate_overload_from_app() {
/*
CREATE OR REPLACE FUNCTION meta.translate_from_app("LangId" integer, "TableName" character varying, "ParentKeyName" character varying, "ParentKeyValue" integer, "FieldName" character varying, "FieldValue" character varying)
RETURNS void
LANGUAGE plpgsql
AS $function$
DECLARE v_sql varchar;
DECLARE v_row_count int;
BEGIN
v_sql := format ('UPDATE %s_lang SET %s = ''%s'' WHERE lang_id = %s and %s = %s', "TableName", "FieldName", "FieldValue", "LangId", "ParentKeyName", "ParentKeyValue");
EXECUTE v_sql;
GET DIAGNOSTICS v_row_count = ROW_COUNT;
IF v_row_count = 0 THEN
v_sql := format ('INSERT INTO %s_lang(lang_id, %s, %s) VALUES (%s, %s, ''%s'')', "TableName", "ParentKeyName", "FieldName", "LangId", "ParentKeyValue", "FieldValue");
EXECUTE v_sql;
END IF;
END
$function$
*/
}
/**
* @function update_backoffice_routes
* @memberof meta
* @description Update backoffice routes in app from auxiliary admin app definition
* @returns {void}
*/
function update_backoffice_routes() {
/*
CREATE OR REPLACE FUNCTION meta.update_backoffice_routes()
RETURNS void
LANGUAGE plpgsql
AS $function$
BEGIN
--DROP FOREIGN TABLE meta.vw_ai4soilhealth_hierarchy;
--IMPORT FOREIGN SCHEMA meta LIMIT TO (vw_ai4soilhealth_hierarchy)
--FROM SERVER gl
--INTO meta;
--GRANT ALL PRIVILEGES ON ALL TABLES IN SCHEMA meta TO gl;
WITH RECURSIVE t AS (
SELECT * FROM meta.route r
WHERE r.name = 'Backoffice'
UNION ALL
SELECT c.* FROM meta.route c
INNER JOIN t ON t.name = c.parent
)
DELETE FROM meta.route r
WHERE name IN (SELECT name FROM t) AND name != 'Backoffice';
--SELECT * FROM t
INSERT INTO meta.route (name, order_no, path, component, icon, parent, props, offline, public, active)
SELECT child, order_no, '/' || child, 'table', 'table_chart', parent, '{ "edit" : "' || proc || '", "frugal" : true }', false, false, true
FROM meta.vw_ai4soilhealth_hierarchy;
END $function$
*/
}
/**
* @function update_i18n_lang
* @memberof meta
* @description Update i18n lang table with new i18n keys and languages
* @returns {void}
*/
function update_i18n_lang() {
/*
CREATE OR REPLACE FUNCTION meta.update_i18n_lang()
RETURNS void
LANGUAGE plpgsql
AS $function$
BEGIN
INSERT INTO meta.i18n_lang (i18n_id, lang_id, value)
SELECT i.id, l.id, i.key
FROM meta.lang l
INNER JOIN meta.i18n i ON 1=1
LEFT JOIN meta.i18n_lang il ON il.lang_id = l.id AND il.i18n_id = i.id
WHERE il.id IS NULL;
END$function$
*/
}
/**
* @function update_time_modified
* @memberof meta
* @description Update time modified
* @returns {trigger}
*/
function update_time_modified() {
/*
CREATE OR REPLACE FUNCTION meta.update_time_modified()
RETURNS trigger
LANGUAGE plpgsql
AS $function$
BEGIN
NEW.time_modified = CURRENT_TIMESTAMP;
RETURN NEW;
END $function$
*/
}
/**
* @function update_user_and_time_modified
* @memberof meta
* @description Update user and time modified
* @returns {trigger}
*/
function update_user_and_time_modified() {
/*
CREATE OR REPLACE FUNCTION meta.update_user_and_time_modified()
RETURNS trigger
LANGUAGE plpgsql
AS $function$
BEGIN
NEW.time_modified = CURRENT_TIMESTAMP;
NEW.user_modified_id = auth.get_context_person_id();
RETURN NEW;
END $function$
*/
}
/**
* @function _safe_execute
* @memberof utils
* @description Safe execute
* @param {text} sql_code
* @param {jsonb} sql_result
* @param {jsonb[]} error_messages
* @param {integer} line_number
* @param {text} json_path
* @returns {record}
*/
function _safe_execute() {
/*
CREATE OR REPLACE FUNCTION utils._safe_execute(sql_code text, INOUT sql_result jsonb, INOUT error_messages jsonb[], line_number integer, json_path text)
RETURNS record
LANGUAGE plpgsql
AS $function$
DECLARE
jsonb_sql_code text;
BEGIN
jsonb_sql_code := FORMAT(
'WITH query AS (%s) SELECT jsonb_agg(row_to_json(query)) FROM query',
sql_code
);
EXECUTE jsonb_sql_code INTO sql_result;
EXCEPTION
WHEN OTHERS THEN
sql_result := NULL;
error_messages := ARRAY_APPEND(
error_messages,
jsonb_build_object(
'type', 'internal',
'error', SQLERRM,
-- TODO: dynamically get function name
'function', 'utils.import_json_object',
'line_number', line_number,
'json_path', json_path,
'sql_query', sql_code
)
);
END;
$function$
*/
}
/**
* @function _safe_execute_temp
* @memberof utils
* @description Safe execute temp
* @param {text} sql_code
* @param {integer} line_number
* @param {text} json_path
* @returns {jsonb}
*/
function _safe_execute_temp() {
/*
CREATE OR REPLACE FUNCTION utils._safe_execute_temp(sql_code text, line_number integer, json_path text)
RETURNS jsonb
LANGUAGE plpgsql
AS $function$
DECLARE
jsonb_sql_code text;
sql_result jsonb := NULL;
BEGIN
jsonb_sql_code := FORMAT(
'WITH query AS (%s) SELECT jsonb_agg(row_to_json(query)) FROM query',
sql_code
);
EXECUTE jsonb_sql_code INTO sql_result;
RETURN jsonb_build_object(
'sql_result', sql_result,
'error_messages', '[]'::jsonb
);
EXCEPTION
WHEN OTHERS THEN
RETURN jsonb_build_object(
'sql_result', sql_result,
'error_messages', jsonb_build_object(
'type', 'internal',
'error', SQLERRM,
-- TODO: dynamically get function name
'function', 'utils.import_json_object',
'line_number', line_number,
'json_path', json_path,
'sql_query', sql_code
)
);
END;
$function$
*/
}
/**
* @function _update_line_numbers_for_error_messages
* @memberof utils
* @description Update line numbers for error messages
* @param {character_varying} function_schema
* @param {character_varying} function_name
* @returns {void}
*/
function _update_line_numbers_for_error_messages() {
/*
CREATE OR REPLACE FUNCTION utils._update_line_numbers_for_error_messages(function_schema character varying, function_name character varying)
RETURNS void
LANGUAGE plpgsql
AS $function$
DECLARE
sql text;
function_code text;
function_lines text[];
line text;
modified_line text;
result_lines text[] := '{}';
BEGIN
sql := FORMAT(
'SELECT pg_get_functiondef(oid) FROM pg_proc
WHERE pronamespace=%L::regnamespace AND proname=%L',
function_schema,
function_name
);
-- RAISE NOTICE '%', sql;
EXECUTE sql INTO function_code;
-- RAISE NOTICE '%', function_code;
IF function_code IS NULL THEN
RAISE EXCEPTION 'Function %I.%I not found', function_schema, function_name;
END IF;
SELECT STRING_TO_ARRAY(function_code, E'\n') into function_lines;
-- RAISE NOTICE 'lines: \n%', function_lines;
FOR line_number IN 1..ARRAY_LENGTH(function_lines, 1) LOOP
line := function_lines[line_number];
IF line ~ '/\* current line number \' THEN
modified_line := REGEXP_REPLACE(
line,
'[0-9]+\s\* current line number \',
FORMAT('%s ', line_number)
);
-- RAISE NOTICE '%', modified_line;
ELSE
modified_line := line;
END IF;
result_lines := ARRAY_APPEND(result_lines, modified_line);
END LOOP;
-- RAISE NOTICE 'lines: \n%', result_lines;
sql := ARRAY_TO_STRING(result_lines, E'\n');
-- RAISE NOTICE '%', sql;
EXECUTE sql;
END;
$function$
*/
}
/**
* @function create_table
* @memberof utils
* @description Create table
* @param {text} v_schema_name
* @param {text} v_table_name
* @returns {void}
*/
function create_table() {
/*
CREATE OR REPLACE FUNCTION utils.create_table(v_schema_name text, v_table_name text)
RETURNS void
LANGUAGE plpgsql
AS $function$BEGIN
EXECUTE format('CREATE TABLE %I.%I ( id integer generated always as identity constraint %I_%I_pk primary key, name varchar NOT NULL)',
v_schema_name, v_table_name, v_schema_name, v_table_name);
EXECUTE format('ALTER TABLE %I.%I OWNER TO gl',
v_schema_name, v_table_name, v_table_name);
END$function$
*/
}
/**
* @function execute_ignore
* @memberof utils
* @description Execute ignore
* @param {character_varying} sql
* @returns {void}
*/
function execute_ignore() {
/*
CREATE OR REPLACE FUNCTION utils.execute_ignore(sql character varying)
RETURNS void
LANGUAGE plpgsql
AS $function$
BEGIN
BEGIN
EXECUTE sql;
EXCEPTION
WHEN others THEN
RAISE NOTICE 'Error executing: % %', SQLERRM, sql;
END;
END;
$function$
*/
}
/**
* @function function_sizes
* @memberof utils
* @description Lists functions count and total size of all functions
* @returns {Object}
* @property {bigint} functions
* @property {bigint} total
*/
function function_sizes() {
/*
CREATE OR REPLACE FUNCTION utils.function_sizes()
RETURNS TABLE(functions bigint, total bigint)
LANGUAGE plpgsql
AS $function$
BEGIN
RETURN QUERY (
SELECT
count(*) functions, sum(length(routine_definition ))
FROM
information_schema.routines
WHERE
specific_schema not in ('information_schema', 'pg_catalog', 'tiger', 'pgstac', 'topology', 'zzz_obsolete', 'public')
);
END $function$
*/
}
/**
* @function grant_all_privileges_to_user
* @memberof utils
* @description Grant all privileges to user
* @param {character_varying} UserName
* @param {character_varying} SchemaName
* @returns {void}
*/
function grant_all_privileges_to_user() {
/*
CREATE OR REPLACE FUNCTION utils.grant_all_privileges_to_user("UserName" character varying, "SchemaName" character varying)
RETURNS void
LANGUAGE plpgsql
AS $function$
DECLARE r RECORD;
BEGIN
-- For each table in the schema, grant necessary privileges
FOR r IN (SELECT tablename FROM pg_tables WHERE schemaname = "SchemaName") LOOP
EXECUTE 'GRANT SELECT, INSERT, UPDATE, DELETE ON ' || "SchemaName" || '.' || quote_ident(r.tablename) || ' TO ' || "UserName";
RAISE NOTICE 'Granted SELECT, INSERT, UPDATE, DELETE on % to %', r.tablename, "UserName";
END LOOP;
END $function$
*/
}
/**
* @function import_json
* @memberof utils
* @description Import json
* @param {character_varying} Json
* @returns {void}
*/
function import_json() {
/*
CREATE OR REPLACE FUNCTION utils.import_json("Json" character varying)
RETURNS void
LANGUAGE plpgsql
AS $function$
DECLARE
json_data jsonb;
key text;
json_value jsonb;
json_value_type text;
key_dot_position integer;
key_path text;
error_json_path text;
error_messages_array jsonb[] := '{}';
error_messages_for_key_array jsonb[] := '{}';
BEGIN
json_data := "Json";
FOR key IN
SELECT JSONB_OBJECT_KEYS(json_data)
LOOP
json_value := json_data->key;
json_value_type := JSONB_TYPEOF(json_value);
key_dot_position := POSITION('.' IN key);
IF key_dot_position > 0 THEN
key_path := FORMAT('[''%s'']', key);
ELSE
key_path := key;
END IF;
error_json_path := FORMAT('$.%s', key_path);
RAISE NOTICE 'error_json_path: %', error_json_path;
IF json_value_type <> 'object' THEN
--
-- TODO: handle wrong json structure
RAISE NOTICE 'WRONG JSON STRUCTURE';
error_messages_for_key_array := ARRAY_APPEND(
'{}',
jsonb_build_object(
'type', 'json',
'error', FORMAT(
'Value %s for top-level key "%s" should not be a scalar, it needs to be an object instead.',
json_value,
key
),
'function', 'utils.import_json',
'line_number', 43 ,
'json_path', error_json_path
)
);
ELSE
SELECT utils.import_json_object(NULL, NULL, key, json_value, error_json_path) INTO error_messages_for_key_array;
END IF;
RAISE NOTICE 'error_messages_for_key: %', error_messages_for_key_array;
error_messages_array := ARRAY_CAT(
error_messages_array,
error_messages_for_key_array
);
END LOOP;
--
-- TODO: uncomment and drop temporary table
-- DROP TABLE IF EXISTS schema_and_table_names_temp;
IF array_length(error_messages_array, 1) IS NOT NULL THEN
RAISE EXCEPTION 'IMPORT_JSON_ERROR: %', TO_JSON(error_messages_array);
END IF;
END
$function$
*/
}
/**
* @function import_json_object
* @memberof utils
* @description Import json object
* @param {character_varying} ParentTable
* @param {integer} ParentId
* @param {character_varying} RecordTable
* @param {jsonb} RecordJson
* @param {text} JsonPath
* @returns {jsonb[]}
*/
function import_json_object() {
/*
CREATE OR REPLACE FUNCTION utils.import_json_object("ParentTable" character varying, "ParentId" integer, "RecordTable" character varying, "RecordJson" jsonb, "JsonPath" text)
RETURNS jsonb[]
LANGUAGE plpgsql
AS $function$
DECLARE
key TEXT;
json_value jsonb;
json_value_type text;
record_data jsonb := '{}';
sub_record_table_names text[] := '{}';
fk_separator_position integer;
fk_table text;
fk_column text;
fk_schema text;
fk_id integer;
sql_code text := '';
sql_result jsonb;
record_id integer = NULL;
record_schema text;
match_parent_condition_part text = '';
sub_record_name text;
error_messages jsonb[] := '{}';
key_dot_position integer;
key_path text;
error_json_path text;
sub_error_messages jsonb[] := '{}';
BEGIN
CREATE TEMP TABLE IF NOT EXISTS schema_and_table_names_temp AS
SELECT schemaname, tablename FROM pg_tables
WHERE tableowner='gl';
--
-- Extract record attributes and values, and table names of sub records
RAISE NOTICE 'RecordTable: %, RecordJson: %', "RecordTable", "RecordJson";
FOR key IN SELECT JSONB_OBJECT_KEYS("RecordJson") LOOP
json_value := "RecordJson"->key;
json_value_type := JSONB_TYPEOF(json_value);
-- RAISE NOTICE 'json_key: %', key;
-- RAISE NOTICE 'json_value_type: %', json_value_type;
IF json_value_type = 'array' OR json_value_type = 'object' THEN
--
-- Object may be used for 1:1 relationship
-- with table that foreign key is associated with
sub_record_table_names := ARRAY_APPEND(
sub_record_table_names,
key
);
ELSE
--
-- Other types like string, number,...
key_dot_position := POSITION('.' IN key);
IF key_dot_position > 0 THEN
key_path := FORMAT('[''%s'']', key);
ELSE
key_path := key;
END IF;
error_json_path := FORMAT('%s.%s', "JsonPath", key_path);
fk_separator_position := POSITION('__' IN key);
-- RAISE NOTICE 'fk_separator_position: %', fk_separator_position;
IF fk_separator_position > 0 THEN
--
-- If key points to foreign key,
-- add foreign key name and value to record_data
fk_table := SUBSTRING(key, 0, fk_separator_position);
fk_column := SUBSTRING(
key,
fk_separator_position + 2,
LENGTH(key) - fk_separator_position - 1
);
-- RAISE NOTICE 'fk_table: %', fk_table;
-- RAISE NOTICE 'fk_column: %', fk_column;
sql_code := FORMAT(
'SELECT schemaname FROM schema_and_table_names_temp WHERE tablename=%L',
fk_table
);
-- RAISE NOTICE '%', sql_code;
-- EXECUTE sql_code INTO fk_schema;
SELECT * INTO sql_result, error_messages
FROM utils._safe_execute(sql_code, sql_result, error_messages, 78 , error_json_path);
fk_schema := sql_result->0->>'schemaname';
IF fk_schema IS NULL THEN
error_messages := ARRAY_APPEND(
error_messages,
jsonb_build_object(
'type', 'json',
'error', FORMAT(
'Table "%s" of foreign key attribute "%s" does not exist in database.',
fk_table,
key
),
'function', 'utils.import_json_object',
'line_number', 91 ,
'json_path', error_json_path
)
);
-- RAISE NOTICE 'schema for fk_table ''%'' is not found', fk_table;
-- ELSE
ELSIF "RecordJson"->>key IS NOT NULL THEN
-- RAISE NOTICE 'fk_schema: %', fk_schema;
sql_code := FORMAT(
'SELECT id FROM %I.%I WHERE %I=%L',
fk_schema, fk_table, fk_column, "RecordJson"->>key
);
-- RAISE NOTICE '%', sql_code;
-- EXECUTE sql_code INTO fk_id;
SELECT * INTO sql_result, error_messages
FROM utils._safe_execute(sql_code, sql_result, error_messages, 106 , error_json_path);
fk_id := sql_result->0->>'id';
-- RAISE NOTICE 'fk_id: %', fk_id;
IF fk_id IS NULL THEN
error_messages := ARRAY_APPEND(
error_messages,
jsonb_build_object(
'type', 'json',
'error', FORMAT(
'Value "%s" for column "%s" in table "%s" specified by foreign key attribute "%s" does not exist.',
"RecordJson"->>key,
fk_column,
fk_table,
key
),
'function', 'utils.import_json_object',
'line_number', 122 ,
'json_path', error_json_path,
'show_table', fk_table,
'show_table_api', FORMAT('%I_%I', fk_schema, fk_table)
)
);
-- RAISE NOTICE 'fk_id not found for %.%.%=''%''', fk_schema, fk_table, fk_column, "RecordJson"->>key;
ELSE
-- RAISE NOTICE 'fk_id is not null: %', fk_id;
record_data := JSONB_SET(
record_data,
ARRAY[FORMAT('%s_id', fk_table)],
TO_JSONB(fk_id)
);
END IF;
END IF;
ELSE
record_data := JSONB_SET(
record_data,
ARRAY[key],
json_value
);
END IF;
END IF;
END LOOP;
RAISE NOTICE 'record_data: %', record_data;
RAISE NOTICE 'sub_record_table_names: %', sub_record_table_names;
--
-- Check if record table exists in database
sql_code := FORMAT(
'SELECT schemaname FROM schema_and_table_names_temp WHERE tablename=%L',
"RecordTable"
);
-- RAISE NOTICE '%', sql_code;
SELECT * INTO sql_result, error_messages
FROM utils._safe_execute(sql_code, sql_result, error_messages, 160 , "JsonPath");
record_schema := sql_result->0->>'schemaname';
IF record_schema IS NULL THEN
error_messages := ARRAY_APPEND(
error_messages,
jsonb_build_object(
'type', 'json',
'error', FORMAT(
'Table "%s" does not exist in database.',
"RecordTable",
key
),
'function', 'utils.import_json_object',
'line_number', 173 ,
'json_path', "JsonPath"
)
);
-- RAISE NOTICE 'schema for RecordTable ''%'' is not found', "RecordTable";
ELSE
--
-- Check if record already exists in table
-- record is searched by name and parent id if provided as argument
IF record_data->>'name' IS NOT NULL THEN
IF "ParentTable" IS NOT NULL AND "ParentId" IS NOT NULL THEN
match_parent_condition_part = FORMAT(
' AND %s_id=%L',
"ParentTable",
"ParentId"
);
END IF;
sql_code := FORMAT(
'SELECT id FROM data.%I WHERE name=%L%s',
"RecordTable",
record_data->>'name',
match_parent_condition_part
);
RAISE NOTICE '%', sql_code;
--
-- TODO: Handle cases when column name does not exist in record table
-- EXECUTE sql_code INTO record_id;
error_json_path := FORMAT('%s.name', "JsonPath");
SELECT * INTO sql_result, error_messages
FROM utils._safe_execute(sql_code, sql_result, error_messages, 202 , error_json_path);
record_id := sql_result->0->>'id';
END IF;
RAISE NOTICE 'data.% record_id: %', "RecordTable", record_id;
IF record_id IS NULL THEN
--
-- Add new record with record data
IF "ParentTable" IS NOT NULL AND "ParentId" IS NOT NULL THEN
record_data := record_data || FORMAT(
'{"%s_id": %s}',
"ParentTable",
"ParentId"
)::jsonb;
END IF;
RAISE NOTICE 'record_data: %', record_data;
sql_code := FORMAT(
'INSERT INTO data.%I (%s) VALUES (%s) RETURNING id',
"RecordTable",
STRING_AGG(QUOTE_IDENT(column_name), ', '),
STRING_AGG(COALESCE(QUOTE_LITERAL(record_data->>column_name), 'NULL'), ', ')
) FROM JSONB_OBJECT_KEYS(record_data) column_name;
RAISE NOTICE '%', sql_code;
--
-- TODO: Handle cases when insert or update violates foreign key constraints
-- EXECUTE sql_code INTO record_id;
SELECT * INTO sql_result, error_messages
FROM utils._safe_execute(sql_code, sql_result, error_messages, 228 , "JsonPath");
record_id := sql_result->0->>'id';
ELSE
--
-- Update existing record with new record data
-- if there is new data other than name that is used for reference
record_data := record_data - 'name';
IF record_data<>'{}' THEN
--
-- id needs to be returned because _safe_execute() expects query to return value
sql_code := FORMAT(
'UPDATE data.%I SET %s WHERE id = %s RETURNING id',
"RecordTable",
STRING_AGG(FORMAT('%I = %L', column_name, record_data->>column_name), ', '),
record_id
) FROM JSONB_OBJECT_KEYS(record_data) column_name;
RAISE NOTICE '%', sql_code;
-- EXECUTE sql_code;
SELECT * INTO sql_result, error_messages
FROM utils._safe_execute(sql_code, sql_result, error_messages, 247 , "JsonPath");
END IF;
END IF;
-- RAISE NOTICE 'error_messages: %', error_messages;
RAISE NOTICE 'data.% record_id: %', "RecordTable", record_id;
-- TODO: remove recursion limitation when function is done
-- IF "RecordTable" <> 'data_source' AND "RecordTable" <> 'site' AND "RecordTable" <> 'point'
-- AND "RecordTable" <> 'sampling_log' AND "RecordTable" <> 'sample'
-- AND "RecordTable" <> 'observation'
-- THEN
-- RAISE NOTICE 'out table: %', "RecordTable";
-- RETURN;
-- END IF;
--
-- For each sub record recursively call this function
FOREACH sub_record_name IN ARRAY sub_record_table_names LOOP
json_value_type := JSONB_TYPEOF("RecordJson"->sub_record_name);
-- RAISE NOTICE 'json_value_type: %', json_value_type;
key_dot_position := POSITION('.' IN sub_record_name);
IF key_dot_position > 0 THEN
key_path := FORMAT('[''%s'']', sub_record_name);
ELSE
key_path := sub_record_name;
END IF;
IF json_value_type = 'object' THEN
sub_error_messages := utils.import_json_object(
"RecordTable",
record_id,
sub_record_name,
"RecordJson"->sub_record_name,
FORMAT('%s.%s', "JsonPath", key_path)
);
error_messages := ARRAY_CAT(
error_messages,
sub_error_messages
);
ELSIF json_value_type = 'array' THEN
FOR json_index IN 1..JSONB_ARRAY_LENGTH("RecordJson"->sub_record_name) LOOP
json_value := "RecordJson"->sub_record_name->(json_index - 1);
sub_error_messages := utils.import_json_object(
"RecordTable",
record_id,
sub_record_name,
json_value,
FORMAT('%s.%s[%s]', "JsonPath", key_path, json_index - 1)
);
error_messages := ARRAY_CAT(
error_messages,
sub_error_messages
);
END LOOP;
END IF;
END LOOP;
END IF;
RETURN error_messages;
END
$function$
*/
}
/**
* @function import_json_object_temp
* @memberof utils
* @description Import json object temp
* @param {character_varying} ParentTable
* @param {integer} ParentId
* @param {character_varying} RecordTable
* @param {jsonb} RecordJson
* @param {character_varying} JsonPath
* @param {character_varying[]} UploadedImages
* @returns {jsonb}
*/
function import_json_object_temp() {
/*
CREATE OR REPLACE FUNCTION utils.import_json_object_temp("ParentTable" character varying, "ParentId" integer, "RecordTable" character varying, "RecordJson" jsonb, "JsonPath" character varying, "UploadedImages" character varying[])
RETURNS jsonb
LANGUAGE plpgsql
AS $function$
DECLARE
key TEXT;
json_value jsonb;
json_value_type text;
record_data jsonb := '{}';
sub_record_table_names text[] := '{}';
fk_separator_position integer;
fk_table text;
fk_column text;
fk_schema text;
fk_id integer;
sql_code text := '';
sql_result jsonb;
record_id integer = NULL;
record_schema text;
match_parent_condition_part text = '';
sub_record_name text;
error_messages jsonb := '[]';
key_dot_position integer;
key_path text;
error_json_path text;
-- sub_error_messages jsonb[] := '{}';
json_result jsonb := '{}';
-- import_result jsonb := '{}';
images_data jsonb := '[]';
BEGIN
CREATE TEMP TABLE IF NOT EXISTS schema_and_table_names_temp AS
SELECT schemaname, tablename FROM pg_tables
WHERE tableowner='gl';
--
-- Extract record attributes and values, and table names of sub records
RAISE NOTICE 'RecordTable: %, RecordJson: %', "RecordTable", "RecordJson";
FOR key IN SELECT JSONB_OBJECT_KEYS("RecordJson") LOOP
json_value := "RecordJson"->key;
json_value_type := JSONB_TYPEOF(json_value);
-- RAISE NOTICE 'json_key: %', key;
-- RAISE NOTICE 'json_value_type: %', json_value_type;
IF json_value_type = 'array' OR json_value_type = 'object' THEN
--
-- Object may be used for 1:1 relationship
-- with table that foreign key is associated with
sub_record_table_names := ARRAY_APPEND(
sub_record_table_names,
key
);
ELSE
--
-- Other types like string, number,...
key_dot_position := POSITION('.' IN key);
IF key_dot_position > 0 THEN
key_path := FORMAT('[''%s'']', key);
ELSE
key_path := key;
END IF;
error_json_path := FORMAT('%s.%s', "JsonPath", key_path);
fk_separator_position := POSITION('__' IN key);
-- RAISE NOTICE 'fk_separator_position: %', fk_separator_position;
IF fk_separator_position > 0 THEN
--
-- If key points to foreign key,
-- add foreign key name and value to record_data
fk_table := SUBSTRING(key, 0, fk_separator_position);
fk_column := SUBSTRING(
key,
fk_separator_position + 2,
LENGTH(key) - fk_separator_position - 1
);
-- RAISE NOTICE 'fk_table: %', fk_table;
-- RAISE NOTICE 'fk_column: %', fk_column;
sql_code := FORMAT(
'SELECT schemaname FROM schema_and_table_names_temp WHERE tablename=%L',
fk_table
);
-- RAISE NOTICE '%', sql_code;
-- EXECUTE sql_code INTO fk_schema;
-- SELECT * INTO sql_result, error_messages
-- FROM utils._safe_execute(sql_code, sql_result, error_messages, 81 , error_json_path);
-- fk_schema := sql_result->0->>'schemaname';
json_result := utils._safe_execute_temp(sql_code, 84 , error_json_path);
fk_schema := json_result->'sql_result'->0->>'schemaname';
error_messages := error_messages || (json_result->'error_messages');
IF fk_schema IS NULL THEN
error_messages := error_messages || jsonb_build_array(
jsonb_build_object(
'type', 'json',
'error', FORMAT(
'Table "%s" of foreign key attribute "%s" does not exist in database.',
fk_table,
key
),
'function', 'utils.import_json_object',
'line_number', 97 ,
'json_path', error_json_path
)
);
-- RAISE NOTICE 'schema for fk_table ''%'' is not found', fk_table;
-- ELSE
ELSIF "RecordJson"->>key IS NOT NULL THEN
-- RAISE NOTICE 'fk_schema: %', fk_schema;
sql_code := FORMAT(
'SELECT id FROM %I.%I WHERE %I=%L',
fk_schema, fk_table, fk_column, "RecordJson"->>key
);
-- RAISE NOTICE '%', sql_code;
-- EXECUTE sql_code INTO fk_id;
-- SELECT * INTO sql_result, error_messages
-- FROM utils._safe_execute(sql_code, sql_result, error_messages, 112 , error_json_path);
-- fk_id := sql_result->0->>'id';
json_result := utils._safe_execute_temp(sql_code, 115 , error_json_path);
fk_id := json_result->'sql_result'->0->>'id';
error_messages := error_messages || (json_result->'error_messages');
-- RAISE NOTICE 'fk_id: %', fk_id;
IF fk_id IS NULL THEN
error_messages := error_messages || jsonb_build_array(
jsonb_build_object(
'type', 'json',
'error', FORMAT(
'Value "%s" for column "%s" in table "%s" specified by foreign key attribute "%s" does not exist.',
"RecordJson"->>key,
fk_column,
fk_table,
key
),
'function', 'utils.import_json_object',
'line_number', 131 ,
'json_path', error_json_path,
'show_table', fk_table,
'show_table_api', FORMAT('%I_%I', fk_schema, fk_table)
)
);
-- RAISE NOTICE 'fk_id not found for %.%.%=''%''', fk_schema, fk_table, fk_column, "RecordJson"->>key;
ELSE
-- RAISE NOTICE 'fk_id is not null: %', fk_id;
record_data := JSONB_SET(
record_data,
ARRAY[FORMAT('%s_id', fk_table)],
TO_JSONB(fk_id)
);
END IF;
END IF;
ELSE
record_data := JSONB_SET(
record_data,
ARRAY[key],
json_value
);
END IF;
END IF;
END LOOP;
RAISE NOTICE 'record_data: %', record_data;
RAISE NOTICE 'sub_record_table_names: %', sub_record_table_names;
--
-- Check if record table exists in database
sql_code := FORMAT(
'SELECT schemaname FROM schema_and_table_names_temp WHERE tablename=%L',
"RecordTable"
);
-- RAISE NOTICE '%', sql_code;
-- SELECT * INTO sql_result, error_messages
-- FROM utils._safe_execute(sql_code, sql_result, error_messages, 169 , "JsonPath");
-- record_schema := sql_result->0->>'schemaname';
json_result := utils._safe_execute_temp(sql_code, 172 , "JsonPath");
record_schema := json_result->'sql_result'->0->>'schemaname';
error_messages := error_messages || (json_result->'error_messages');
IF record_schema IS NULL THEN
error_messages := error_messages || jsonb_build_array(
jsonb_build_object(
'type', 'json',
'error', FORMAT(
'Table "%s" does not exist in database.',
"RecordTable",
key
),
'function', 'utils.import_json_object',
'line_number', 185 ,
'json_path', "JsonPath"
)
);
-- RAISE NOTICE 'schema for RecordTable ''%'' is not found', "RecordTable";
ELSE
--
-- Check if record already exists in table
-- record is searched by name and parent id if provided as argument
IF record_data->>'name' IS NOT NULL THEN
IF "ParentTable" IS NOT NULL AND "ParentId" IS NOT NULL THEN
match_parent_condition_part = FORMAT(
' AND %s_id=%L',
"ParentTable",
"ParentId"
);
END IF;
sql_code := FORMAT(
'SELECT id FROM data.%I WHERE name=%L%s',
"RecordTable",
record_data->>'name',
match_parent_condition_part
);
RAISE NOTICE '%', sql_code;
--
-- TODO: Handle cases when column name does not exist in record table
-- EXECUTE sql_code INTO record_id;
error_json_path := FORMAT('%s.name', "JsonPath");
-- SELECT * INTO sql_result, error_messages
-- FROM utils._safe_execute(sql_code, sql_result, error_messages, 214 , error_json_path);
-- record_id := sql_result->0->>'id';
json_result := utils._safe_execute_temp(sql_code, 217 , error_json_path);
record_id := json_result->'sql_result'->0->>'id';
error_messages := error_messages || (json_result->'error_messages');
END IF;
RAISE NOTICE 'data.% record_id: %', "RecordTable", record_id;
IF record_id IS NULL THEN
--
-- Add new record with record data
IF "ParentTable" IS NOT NULL AND "ParentId" IS NOT NULL THEN
record_data := record_data || FORMAT(
'{"%s_id": %s}',
"ParentTable",
"ParentId"
)::jsonb;
END IF;
RAISE NOTICE 'record_data: %', record_data;
sql_code := FORMAT(
'INSERT INTO data.%I (%s) VALUES (%s) RETURNING id',
"RecordTable",
STRING_AGG(QUOTE_IDENT(column_name), ', '),
STRING_AGG(QUOTE_LITERAL(record_data->>column_name), ', ')
) FROM JSONB_OBJECT_KEYS(record_data) column_name;
RAISE NOTICE '%', sql_code;
--
-- TODO: Handle cases when insert or update violates foreign key constraints
-- EXECUTE sql_code INTO record_id;
-- SELECT * INTO sql_result, error_messages
-- FROM utils._safe_execute(sql_code, sql_result, error_messages, 244 , "JsonPath");
-- record_id := sql_result->0->>'id';
json_result := utils._safe_execute_temp(sql_code, 246 , "JsonPath");
record_id := json_result->'sql_result'->0->>'id';
error_messages := error_messages || (json_result->'error_messages');
ELSE
--
-- Update existing record with new record data
-- if there is new data other than name that is used for reference
record_data := record_data - 'name';
IF record_data<>'{}' THEN
--
-- id needs to be returned because _safe_execute() expects query to return value
sql_code := FORMAT(
'UPDATE data.%I SET %s WHERE id = %s RETURNING id',
"RecordTable",
STRING_AGG(FORMAT('%I = %L', column_name, record_data->>column_name), ', '),
record_id
) FROM JSONB_OBJECT_KEYS(record_data) column_name;
RAISE NOTICE '%', sql_code;
-- EXECUTE sql_code;
-- SELECT * INTO sql_result, error_messages
-- FROM utils._safe_execute(sql_code, sql_result, error_messages, 266 , "JsonPath");
json_result := utils._safe_execute_temp(sql_code, 268 , "JsonPath");
error_messages := error_messages || (json_result->'error_messages');
END IF;
END IF;
-- RAISE NOTICE 'error_messages: %', error_messages;
RAISE NOTICE 'data.% record_id: %', "RecordTable", record_id;
IF "RecordTable" = 'sampling_log_image' THEN
RAISE NOTICE 'sampling_log_image->>''file_name'', %', record_data->>'file_name';
RAISE NOTICE 'UploadedImages, %', "UploadedImages";
RAISE NOTICE 'not in UploadedImages, %', NOT record_data->>'file_name' = ANY("UploadedImages");
IF record_data->>'file_name' IS NULL THEN
error_messages := error_messages || jsonb_build_array(
jsonb_build_object(
'type', 'json',
'error', 'Value for column "file_name" in table "sampling_log_image" must be specified.',
'function', 'utils.import_json_object',
'line_number', 185 ,
'json_path', "JsonPath"
)
);
ELSIF NOT record_data->>'file_name' = ANY("UploadedImages") THEN
error_messages := error_messages || jsonb_build_array(
jsonb_build_object(
'type', 'json',
'error', FORMAT('Image file "%s" is not uploaded.', (record_data->>'file_name')),
'function', 'utils.import_json_object',
'line_number', 185 ,
'json_path', "JsonPath"
)
);
ELSE
images_data := images_data || jsonb_build_array(
jsonb_build_object(
'id', record_id,
'file_name', record_data->>'file_name',
'error_information', jsonb_build_object(
'type', 'json',
'function', 'utils.import_json_object',
'line_number', 185 ,
'json_path', "JsonPath"
)
)
);
END IF;
END IF;
-- TODO: remove recursion limitation when function is done
-- IF "RecordTable" <> 'data_source' AND "RecordTable" <> 'site' AND "RecordTable" <> 'point'
-- AND "RecordTable" <> 'sampling_log' AND "RecordTable" <> 'sample'
-- AND "RecordTable" <> 'observation'
-- THEN
-- RAISE NOTICE 'out table: %', "RecordTable";
-- RETURN;
-- END IF;
-- For each sub record recursively call this function
FOREACH sub_record_name IN ARRAY sub_record_table_names LOOP
json_value_type := JSONB_TYPEOF("RecordJson"->sub_record_name);
-- RAISE NOTICE 'json_value_type: %', json_value_type;
key_dot_position := POSITION('.' IN sub_record_name);
IF key_dot_position > 0 THEN
key_path := FORMAT('[''%s'']', sub_record_name);
ELSE
key_path := sub_record_name;
END IF;
IF json_value_type = 'object' THEN
-- sub_error_messages := utils.import_json_object(
-- "RecordTable",
-- record_id,
-- sub_record_name,
-- "RecordJson"->sub_record_name,
-- FORMAT('%s.%s', "JsonPath", key_path)
-- );
-- sub_error_messages := json_result->>'error_messages';
json_result := utils.import_json_object_temp(
"RecordTable",
record_id,
sub_record_name,
"RecordJson"->sub_record_name,
FORMAT('%s.%s', "JsonPath", key_path),
"UploadedImages"
);
error_messages := error_messages || (json_result->'error_messages');
images_data := images_data || (json_result->'images_data');
ELSIF json_value_type = 'array' THEN
FOR json_index IN 1..JSONB_ARRAY_LENGTH("RecordJson"->sub_record_name) LOOP
json_value := "RecordJson"->sub_record_name->(json_index - 1);
-- sub_error_messages := utils.import_json_object(
-- "RecordTable",
-- record_id,
-- sub_record_name,
-- json_value,
-- FORMAT('%s.%s[%s]', "JsonPath", key_path, json_index - 1)
-- );
json_result := utils.import_json_object_temp(
"RecordTable",
record_id,
sub_record_name,
json_value,
FORMAT('%s.%s[%s]', "JsonPath", key_path, json_index - 1),
"UploadedImages"
);
error_messages := error_messages || (json_result->'error_messages');
images_data := images_data || (json_result->'images_data');
END LOOP;
END IF;
END LOOP;
END IF;
--RETURN error_messages;
-- RAISE NOTICE 'ijo error_messages: %', error_messages;
RETURN jsonb_build_object(
'error_messages', error_messages,
'images_data', images_data
);
END
$function$
*/
}
/**
* @function import_json_temp
* @memberof utils
* @description Import json temp
* @param {character_varying} Json
* @param {character_varying[]} UploadedImages
* @returns {json}
*/
function import_json_temp() {
/*
CREATE OR REPLACE FUNCTION utils.import_json_temp("Json" character varying, "UploadedImages" character varying[])
RETURNS json
LANGUAGE plpgsql
AS $function$
DECLARE
json_data jsonb;
key text;
json_value jsonb;
json_value_type text;
key_dot_position integer;
key_path text;
error_json_path text;
error_messages_array jsonb := '[]';
error_messages_for_key_array jsonb := '[]';
json_result jsonb := '{}';
-- import_result jsonb := '{}';
images_data jsonb := '[]';
BEGIN
json_data := "Json";
FOR key IN
SELECT JSONB_OBJECT_KEYS(json_data)
LOOP
json_value := json_data->key;
json_value_type := JSONB_TYPEOF(json_value);
key_dot_position := POSITION('.' IN key);
IF key_dot_position > 0 THEN
key_path := FORMAT('[''%s'']', key);
ELSE
key_path := key;
END IF;
error_json_path := FORMAT('$.%s', key_path);
RAISE NOTICE 'error_json_path: %', error_json_path;
IF json_value_type <> 'object' THEN
--
-- TODO: handle wrong json structure
RAISE NOTICE 'WRONG JSON STRUCTURE';
error_messages_for_key_array := jsonb_build_array(
jsonb_build_object(
'type', 'json',
'error', FORMAT(
'Value %s for top-level key "%s" should not be a scalar, it needs to be an object instead.',
json_value,
key
),
'function', 'utils.import_json',
'line_number', 46 ,
'json_path', error_json_path
)
);
ELSE
-- SELECT utils.import_json_object(NULL, NULL, key, json_value, error_json_path) INTO error_messages_for_key_array;
-- SELECT utils.import_json_object(NULL, NULL, key, json_value, error_json_path) INTO json_result;
-- error_messages_for_key_array := utils.import_json_object(
json_result := utils.import_json_object_temp(
NULL,
NULL,
key,
json_value,
error_json_path,
"UploadedImages"
);
error_messages_for_key_array := json_result->'error_messages';
images_data := images_data || (json_result->'images_data');
END IF;
RAISE NOTICE 'error_messages_for_key: %', error_messages_for_key_array;
error_messages_array := error_messages_array || error_messages_for_key_array;
END LOOP;
--
-- TODO: uncomment and drop temporary table
-- DROP TABLE IF EXISTS schema_and_table_names_temp;
-- IF array_length(error_messages_array, 1) IS NOT NULL THEN
RAISE NOTICE 'error_messages_array: %', error_messages_array;
IF jsonb_array_length(error_messages_array) > 0 THEN
RAISE EXCEPTION 'IMPORT_JSON_ERROR: %', TO_JSON(error_messages_array);
END IF;
RAISE NOTICE 'images_data: %', images_data;
-- RETURN images_data;
RETURN jsonb_build_object(
'images_data', images_data
);
END
$function$
*/
}
/**
* @function move
* @memberof utils
* @description Move
* @param {character_varying} SchemaName
* @param {character_varying} TableName
* @param {character_varying} NewSchema
* @returns {void}
*/
function move() {
/*
CREATE OR REPLACE FUNCTION utils.move("SchemaName" character varying, "TableName" character varying, "NewSchema" character varying)
RETURNS void
LANGUAGE plpgsql
AS $function$
DECLARE sql text;
nspname text;
proname text;
old_name text;
new_name text;
old_proc_name text;
new_proc_name text;
old_table_name text;
new_table_name text;
recreate boolean;
v_oid oid;
BEGIN
old_name := "SchemaName" || '.' || "TableName" || ' ';
new_name := "NewSchema" || '.' || "TableName" || ' ';
old_proc_name := "SchemaName" || '_' || "TableName" || '_';
new_proc_name := "NewSchema" || '_' || "TableName" || '_';
old_table_name := '"' || "SchemaName" || '_' || "TableName" || '"';
new_table_name := '"' || "NewSchema" || '_' || "TableName" || '"';
PERFORM utils.execute_ignore('ALTER TABLE ' || "SchemaName" || '.' || "TableName" || ' SET SCHEMA ' || "NewSchema");
FOR nspname, proname, sql, v_oid IN
SELECT
n.nspname,
p.proname,
pg_get_functiondef(p.oid) AS function_definition,
p.oid
FROM pg_proc p
INNER JOIN pg_namespace n ON (p.pronamespace = n.oid)
LEFT JOIN pg_description s ON s.objoid = p.oid
WHERE n.nspname in ('auth', 'analysis', 'catalog', 'data', 'edna', 'general', 'log', 'macrofauna', 'meta', 'osm', 'spectra', 'utils', 'zzglc', 'zzgll', 'zzhistory')
LOOP
UPDATE meta.route SET props = replace(props::text, old_proc_name, new_proc_name)::json WHERE position(old_proc_name IN props::text) > 0;
UPDATE meta.route SET props = replace(props::text, old_table_name, new_table_name)::json WHERE position(old_table_name IN props::text) > 0;
recreate := false;
IF position(old_proc_name IN sql) > 0 THEN
sql := replace(sql, old_proc_name, new_proc_name);
recreate := true;
END IF;
IF position(old_name IN sql) > 0 THEN
sql := replace(sql, old_name, new_name);
recreate := true;
END IF;
IF recreate THEN
RAISE NOTICE 'Recreating function %.%', nspname, proname;
PERFORM utils.execute_ignore('DROP FUNCTION ' || nspname || '.' || proname ||
'(' || pg_get_function_identity_arguments(v_oid) || ');');
RAISE NOTICE '%', sql;
EXECUTE sql;
END IF;
END LOOP;
PERFORM utils.execute_ignore('DROP FUNCTION zzglc.' || "SchemaName" || '_' || "TableName" || '_c');
PERFORM utils.execute_ignore('DROP FUNCTION zzglc.' || "SchemaName" || '_' || "TableName" || '_r');
PERFORM utils.execute_ignore('DROP FUNCTION zzglc.' || "SchemaName" || '_' || "TableName" || '_u');
PERFORM utils.execute_ignore('DROP FUNCTION zzglc.' || "SchemaName" || '_' || "TableName" || '_d');
PERFORM utils.execute_ignore('DROP FUNCTION zzgll.' || "SchemaName" || '_' || "TableName" || '_l');
END $function$
*/
}
/**
* @function normalize_separators
* @memberof utils
* @description Normalize separators
* @param {text} input_text
* @returns {text}
*/
function normalize_separators() {
/*
CREATE OR REPLACE FUNCTION utils.normalize_separators(input_text text)
RETURNS text
LANGUAGE plpgsql
AS $function$
BEGIN
RETURN REGEXP_REPLACE(input_text, '[\s,]+', ',', 'g');
END;
$function$
*/
}
/**
* @function qualify_fk
* @memberof utils
* @description Qualify fk
* @param {character_varying} Att
* @param {character_varying} Qual
* @returns {void}
*/
function qualify_fk() {
/*
CREATE OR REPLACE FUNCTION utils.qualify_fk("Att" character varying, "Qual" character varying)
RETURNS void
LANGUAGE plpgsql
AS $function$
DECLARE sql text;
nspname text;
proname text;
old_name text;
new_name text;
old_proc_name text;
new_proc_name text;
old_table_name text;
new_table_name text;
BEGIN
FOR nspname, proname, sql IN
SELECT
n.nspname,
p.proname,
pg_get_functiondef(p.oid) AS function_definition
FROM pg_proc p
INNER JOIN pg_namespace n ON (p.pronamespace = n.oid)
LEFT JOIN pg_description s ON s.objoid = p.oid
WHERE n.nspname in ('auth', 'analysis', 'catalog', 'data', 'edna', 'general', 'log', 'macrofauna', 'meta', 'osm', 'spectra', 'utils', 'zzglc', 'zzgll', 'zzhistory')
LOOP
IF position("Att" || '_id_val character varying' IN sql) > 0 THEN
sql := replace(sql, "Att" || '_id_val character varying', "Qual" || '__' || "Att" || '_id_val character varying');
sql := replace(sql, "Att" || '_id integer', "Qual" || '__' || "Att" || '_id integer');
raise notice '%.%', nspname, proname;
EXECUTE 'DROP FUNCTION ' || nspname || '.' || proname || '()';
EXECUTE sql;
END IF;
END LOOP;
END $function$
*/
}
/**
* @function rename_fk
* @memberof utils
* @description Rename fk
* @returns {void}
*/
function rename_fk() {
/*
CREATE OR REPLACE FUNCTION utils.rename_fk()
RETURNS void
LANGUAGE plpgsql
AS $function$
DECLARE sql text;
r record;
new_name text;
BEGIN
FOR r IN
SELECT
conname AS constraint_name,
(conrelid::regclass)::text AS table_name,
a.attname AS column_name
FROM pg_constraint c
JOIN pg_attribute a ON a.attnum = ANY (c.conkey) AND a.attrelid = c.conrelid
WHERE c.contype = 'f' -- Foreign key constraints
LOOP
-- Construct the new name for the foreign key
new_name := REPLACE(r.table_name,'.', '_') || '_' || r.column_name || '_fk';
-- Rename the constraint if the new name is different from the current one
IF r.constraint_name != new_name THEN
sql := 'ALTER TABLE ' || r.table_name || ' RENAME CONSTRAINT ' || r.constraint_name || ' TO ' || new_name;
raise notice '%', sql;
PERFORM utils.execute_ignore(sql);
END IF;
END LOOP;
END $function$
*/
}
/**
* @function replace
* @memberof utils
* @description Replace
* @param {character_varying} OldString
* @param {character_varying} NewString
* @returns {void}
*/
function replace() {
/*
CREATE OR REPLACE FUNCTION utils.replace("OldString" character varying, "NewString" character varying)
RETURNS void
LANGUAGE plpgsql
AS $function$
DECLARE sql text;
nspname text;
proname text;
BEGIN
FOR nspname, proname, sql IN
SELECT
n.nspname,
p.proname,
pg_get_functiondef(p.oid) AS function_definition
FROM pg_proc p
INNER JOIN pg_namespace n ON (p.pronamespace = n.oid)
LEFT JOIN pg_description s ON s.objoid = p.oid
WHERE n.nspname in ('auth', 'analysis', 'catalog', 'data', 'edna', 'general', 'log', 'macrofauna', 'meta', 'osm', 'spectra', 'utils', 'zzglc', 'zzgll', 'zzhistory')
LOOP
IF position("OldString" IN sql) > 0 THEN
sql := replace(sql, "OldString", "NewString");
raise notice '%.%', nspname, proname;
EXECUTE sql;
END IF;
END LOOP;
END $function$
*/
}
/**
* @function set_catalog_values
* @memberof utils
* @description Set catalog values
* @param {text} v_schema_name
* @param {text} v_table_name
* @param {text[]} names
* @returns {integer[]}
*/
function set_catalog_values() {
/*
CREATE OR REPLACE FUNCTION utils.set_catalog_values(v_schema_name text, v_table_name text, names text[])
RETURNS integer[]
LANGUAGE plpgsql
AS $function$DECLARE
v_ids INT[];
cmd TEXT;
BEGIN
-- Check if the table exists
IF NOT EXISTS (
SELECT 1 FROM information_schema.tables
WHERE table_schema = v_schema_name
AND table_name = v_table_name
) THEN
RAISE EXCEPTION 'Table %.% does not exist',
v_schema_name, v_table_name;
END IF;
-- Check if the column 'id' exists in the table
IF NOT EXISTS (
SELECT 1 FROM information_schema.columns
WHERE table_schema = v_schema_name
AND table_name = v_table_name
AND column_name = 'id'
) THEN
RAISE EXCEPTION 'Column "id" does not exist in table %.%',
v_schema_name, v_table_name;
END IF;
-- Check if the column 'name' exists in the table
IF NOT EXISTS (
SELECT 1 FROM information_schema.columns
WHERE table_schema = v_schema_name
AND table_name = v_table_name
AND column_name = 'name'
) THEN
RAISE EXCEPTION 'Column "name" does not exist in table %.%',
v_schema_name, v_table_name;
END IF;
cmd := format(
'WITH inserted_ids AS (
INSERT INTO %I.%I (name)
SELECT unnest($1) RETURNING id
)
SELECT array_agg(id) FROM inserted_ids',
v_schema_name, v_table_name
);
EXECUTE cmd
USING names
INTO v_ids;
RETURN v_ids;
END
$function$
*/
}
/**
* @function set_catalog_values_1
* @memberof utils
* @description Set catalog values 1
* @param {text} p_schema_name
* @param {text} p_table_name
* @param {text} p_column_name
* @param {text} p_csv_string
* @returns {void}
*/
function set_catalog_values_1() {
/*
CREATE OR REPLACE FUNCTION utils.set_catalog_values_1(p_schema_name text, p_table_name text, p_column_name text, p_csv_string text)
RETURNS void
LANGUAGE plpgsql
AS $function$
DECLARE
value TEXT;
value_list TEXT[];
sql_query TEXT;
BEGIN
-- Split the CSV string into an array
value_list := string_to_array(p_csv_string, ',');
-- Loop through each value in the array
FOREACH value IN ARRAY value_list
LOOP
RAISE NOTICE 'Inserting value: %', value;
-- Prepare the SQL insert statement
sql_query := format(
'INSERT INTO %I.%I (%I) VALUES ($1)',
p_schema_name, p_table_name, p_column_name, replace(value, '"', '')
);
RAISE NOTICE 'SQL Query: %', sql_query;
-- Execute the dynamic SQL with the value
EXECUTE sql_query USING trim(replace(value, '"', ''));
END LOOP;
END;
$function$
*/
}
/**
* @function set_function_owners
* @memberof utils
* @description Set owner of all functions in the current database to the specified owner
* @param {text} owner_name
* @returns {void}
*/
function set_function_owners() {
/*
CREATE OR REPLACE FUNCTION utils.set_function_owners(owner_name text)
RETURNS void
LANGUAGE plpgsql
AS $function$
DECLARE
nspname text;
proname text;
sql text;
v_oid oid;
BEGIN
-- Loop through all procedures in the current database
FOR nspname, proname, sql, v_oid IN
SELECT
n.nspname,
p.proname,
pg_get_functiondef(p.oid) AS function_definition,
p.oid
FROM pg_proc p
INNER JOIN pg_namespace n ON (p.pronamespace = n.oid)
LEFT JOIN pg_description s ON s.objoid = p.oid
WHERE n.nspname in ('auth', 'analysis', 'catalog', 'data', 'edna', 'general', 'log', 'macrofauna', 'meta', 'osm', 'spectra', 'utils', 'zzglc', 'zzgll', 'zzhistory')
AND p.prokind='f'
loop
-- Build and execute dynamic SQL to set procedure owner
RAISE NOTICE '%.%', nspname, proname;
--EXECUTE format('ALTER FUNCTION %I.%I OWNER TO %I', nspname, proname, owner_name);
EXECUTE 'ALTER FUNCTION ' || nspname || '.' || proname ||
'(' || pg_get_function_identity_arguments(v_oid) || ') OWNER TO ' || owner_name || ';';
END LOOP;
END $function$
*/
}
/**
* @function set_table_owners
* @memberof utils
* @description Set owner of all tables in the current database to the specified owner
* @param {text} owner_name
* @returns {void}
*/
function set_table_owners() {
/*
CREATE OR REPLACE FUNCTION utils.set_table_owners(owner_name text)
RETURNS void
LANGUAGE plpgsql
AS $function$
DECLARE
table_record RECORD;
BEGIN
-- Loop through all tables in the current database
FOR table_record IN
SELECT table_schema, table_name
FROM information_schema.tables
WHERE table_schema in ('auth', 'data', 'catalog', 'edna', 'macrofauna', 'spectra', 'general', 'log', 'meta', 'osm', 'utils', 'zzglc', 'zzgll', 'zzhistory')
AND table_type = 'BASE TABLE'
LOOP
-- Build and execute dynamic SQL to set table owner
EXECUTE format('ALTER TABLE %I.%I OWNER TO %I', table_record.table_schema, table_record.table_name, owner_name);
END LOOP;
END;
$function$
*/
}
/**
* @function table_sizes
* @memberof utils
* @description Reports table sizes
* @returns {Object}
* @property {character_varying} schema_name
* @property {character_varying} table_name
* @property {character_varying} size_pretty
* @property {bigint} size
* @property {bigint} records
*/
function table_sizes() {
/*
CREATE OR REPLACE FUNCTION utils.table_sizes()
RETURNS TABLE(schema_name character varying, table_name character varying, size_pretty character varying, size bigint, records bigint)
LANGUAGE plpgsql
AS $function$
BEGIN
RETURN QUERY
select
t.table_schema::varchar,
t.table_name::varchar,
pg_size_pretty(pg_relation_size('"'||t.table_schema||'"."'||t.table_name||'"'))::varchar,
pg_relation_size('"'||t.table_schema||'"."'||t.table_name||'"'),
ut.n_live_tup AS records
from information_schema.tables t
left join pg_catalog.pg_stat_user_tables ut on ut.schemaname = t.table_schema and ut.relname = t.table_name
where t.table_type = 'BASE TABLE' and t.table_schema not in ('information_schema', 'pg_catalog', 'tiger', 'pgstac', 'topology', 'zzz_obsolete')
order by 4 desc;
END
$function$
*/
}
/**
* @function auth_data_source_person_c
* @memberof zzglc
* @description Auth data source person c
* @param {character_varying} Json
* @returns {integer}
*/
function auth_data_source_person_c() {
/*
CREATE OR REPLACE FUNCTION zzglc.auth_data_source_person_c("Json" character varying)
RETURNS integer
LANGUAGE plpgsql
AS $function$
DECLARE v_id integer;
DECLARE json_data json;
BEGIN
json_data := "Json";
INSERT INTO auth.data_source_person (data_source_id, person_id)
VALUES ((json_data->>'data_source_id')::integer, (json_data->>'person_id')::integer)
RETURNING id INTO v_id;
RETURN v_id;
END $function$
*/
}
/**
* @function auth_data_source_person_d
* @memberof zzglc
* @description Auth data source person d
* @param {integer} Key
* @returns {void}
*/
function auth_data_source_person_d() {
/*
CREATE OR REPLACE FUNCTION zzglc.auth_data_source_person_d("Key" integer)
RETURNS void
LANGUAGE plpgsql
AS $function$
BEGIN
DELETE FROM auth.data_source_person WHERE id = "Key";
END;
$function$
*/
}
/**
* @function auth_data_source_person_r
* @memberof zzglc
* @description Auth data source person r
* @param {integer} Key
* @returns {Object} integer idinteger data_data_source__data_source_idinteger auth_person__person_idcharacter_varying data_data_source__data_source_id_valcharacter_varying auth_person__person_id_val
*/
function auth_data_source_person_r() {
/*
CREATE OR REPLACE FUNCTION zzglc.auth_data_source_person_r("Key" integer)
RETURNS TABLE(id integer, data_data_source__data_source_id integer, auth_person__person_id integer, data_data_source__data_source_id_val character varying, auth_person__person_id_val character varying)
LANGUAGE plpgsql
AS $function$
BEGIN
RETURN QUERY (
SELECT t.id, t.data_source_id, t.person_id, data_source_id.name, person_id.name
FROM auth.data_source_person t
LEFT JOIN data.data_source data_source_id ON data_source_id.id = t.data_source_id
LEFT JOIN auth.person person_id ON person_id.id = t.person_id
WHERE t.data_source_id = "Key"
ORDER BY 2
);
END $function$
*/
}
/**
* @function auth_data_source_person_r_overload
* @overload auth_data_source_person_r
* @memberof zzglc
* @description Auth data source person r
* @returns {Object} integer idinteger data_data_source__data_source_idinteger auth_person__person_idcharacter_varying data_data_source__data_source_id_valcharacter_varying auth_person__person_id_val
*/
function auth_data_source_person_r_overload() {
/*
CREATE OR REPLACE FUNCTION zzglc.auth_data_source_person_r()
RETURNS TABLE(id integer, data_data_source__data_source_id integer, auth_person__person_id integer, data_data_source__data_source_id_val character varying, auth_person__person_id_val character varying)
LANGUAGE plpgsql
AS $function$
BEGIN
RETURN QUERY (
SELECT t.id, t.data_source_id, t.person_id, data_source_id.name, person_id.name
FROM auth.data_source_person t
LEFT JOIN data.data_source data_source_id ON data_source_id.id = t.data_source_id
LEFT JOIN auth.person person_id ON person_id.id = t.person_id
ORDER BY 2
);
END $function$
*/
}
/**
* @function auth_data_source_person_u
* @memberof zzglc
* @description Auth data source person u
* @param {character_varying} Json
* @returns {void}
*/
function auth_data_source_person_u() {
/*
CREATE OR REPLACE FUNCTION zzglc.auth_data_source_person_u("Json" character varying)
RETURNS void
LANGUAGE plpgsql
AS $function$
DECLARE json_data json;
BEGIN
json_data := "Json";
UPDATE auth.data_source_person SET
data_source_id = (json_data->>'data_source_id')::integer,
person_id = (json_data->>'person_id')::integer
WHERE id = (json_data->>'id')::integer;
END $function$
*/
}
/**
* @function auth_log_c
* @memberof zzglc
* @description Auth log c
* @param {character_varying} Json
* @returns {void}
*/
function auth_log_c() {
/*
CREATE OR REPLACE FUNCTION zzglc.auth_log_c("Json" character varying)
RETURNS void
LANGUAGE plpgsql
AS $function$
BEGIN
INSERT INTO auth.log (
person_id,
ip
)
SELECT
U.person_id,
U.ip
FROM
json_to_record("Json"::json) U (
person_id integer,
ip character varying
)
;
END $function$
*/
}
/**
* @function auth_log_d
* @memberof zzglc
* @description Auth log d
* @param {integer} Key
* @returns {void}
*/
function auth_log_d() {
/*
CREATE OR REPLACE FUNCTION zzglc.auth_log_d("Key" integer)
RETURNS void
LANGUAGE plpgsql
AS $function$
BEGIN
DELETE FROM auth.log
WHERE id = "Key";
END $function$
*/
}
/**
* @function auth_log_r
* @memberof zzglc
* @description Auth log r
* @returns {Object}
* @property {integer} id
* @property {integer} person_id
* @property {character_varying} ip
* @property {timestamp_without_time_zone} time_modified
* @property {character_varying} person_id_val
*/
function auth_log_r() {
/*
CREATE OR REPLACE FUNCTION zzglc.auth_log_r()
RETURNS TABLE(id integer, auth_person__person_id integer, ip character varying, time_modified timestamp without time zone, auth_person__person_id_val character varying)
LANGUAGE plpgsql
AS $function$
BEGIN
RETURN QUERY
SELECT
t.id, t.person_id, t.ip, t.time_modified
, person_id_t.name::VARCHAR AS person_id_val
FROM auth.log t
LEFT JOIN auth.person person_id_t ON person_id_t.id = t.person_id
ORDER BY t.id desc
;
END $function$
*/
}
/**
* @function auth_log_u
* @memberof zzglc
* @description Auth log u
* @param {character_varying} Json
* @returns {void}
*/
function auth_log_u() {
/*
CREATE OR REPLACE FUNCTION zzglc.auth_log_u("Json" character varying)
RETURNS void
LANGUAGE plpgsql
AS $function$
DECLARE v_row_count INTEGER;
BEGIN
UPDATE auth.log t
SET person_id = U.person_id,
ip = U.ip
FROM json_to_record("Json"::json) AS U (
id integer,
person_id integer,
ip character varying,
time_modified timestamp without time zone
)
WHERE U.id = t.id
AND t.time_modified = U.time_modified;
GET DIAGNOSTICS v_row_count = ROW_COUNT;
IF v_row_count = 0 THEN
SELECT meta.raise_error(2);
END IF
;
END $function$
*/
}
/**
* @function auth_news_role_c
* @memberof zzglc
* @description Auth news role c
* @param {character_varying} Json
* @returns {integer}
*/
function auth_news_role_c() {
/*
CREATE OR REPLACE FUNCTION zzglc.auth_news_role_c("Json" character varying)
RETURNS integer
LANGUAGE plpgsql
AS $function$
DECLARE v_id integer;
DECLARE json_data json;
BEGIN
json_data := "Json";
INSERT INTO auth.news_role (news_id, role_id)
VALUES ((json_data->>'news_id')::integer, (json_data->>'role_id')::integer)
RETURNING id INTO v_id;
RETURN v_id;
END $function$
*/
}
/**
* @function auth_news_role_d
* @memberof zzglc
* @description Auth news role d
* @param {integer} Key
* @returns {void}
*/
function auth_news_role_d() {
/*
CREATE OR REPLACE FUNCTION zzglc.auth_news_role_d("Key" integer)
RETURNS void
LANGUAGE plpgsql
AS $function$
BEGIN
DELETE FROM auth.news_role WHERE id = "Key";
END;
$function$
*/
}
/**
* @function auth_news_role_r
* @memberof zzglc
* @description Auth news role r
* @param {integer} Key
* @returns {Object} integer idinteger meta_news__news_idinteger auth_role__role_idcharacter_varying meta_news__news_id_valcharacter_varying auth_role__role_id_val
*/
function auth_news_role_r() {
/*
CREATE OR REPLACE FUNCTION zzglc.auth_news_role_r("Key" integer)
RETURNS TABLE(id integer, meta_news__news_id integer, auth_role__role_id integer, meta_news__news_id_val character varying, auth_role__role_id_val character varying)
LANGUAGE plpgsql
AS $function$
BEGIN
RETURN QUERY (
SELECT t.id, t.news_id, t.role_id, news_id.name, role_id.name
FROM auth.news_role t
LEFT JOIN meta.news news_id ON news_id.id = t.news_id
LEFT JOIN auth.role role_id ON role_id.id = t.role_id
WHERE t.news_id = "Key"
ORDER BY 2
);
END $function$
*/
}
/**
* @function auth_news_role_r_overload
* @overload auth_news_role_r
* @memberof zzglc
* @description Auth news role r
* @returns {Object} integer idinteger meta_news__news_idinteger auth_role__role_idcharacter_varying meta_news__news_id_valcharacter_varying auth_role__role_id_val
*/
function auth_news_role_r_overload() {
/*
CREATE OR REPLACE FUNCTION zzglc.auth_news_role_r()
RETURNS TABLE(id integer, meta_news__news_id integer, auth_role__role_id integer, meta_news__news_id_val character varying, auth_role__role_id_val character varying)
LANGUAGE plpgsql
AS $function$
BEGIN
RETURN QUERY (
SELECT t.id, t.news_id, t.role_id, news_id.name, role_id.name
FROM auth.news_role t
LEFT JOIN meta.news news_id ON news_id.id = t.news_id
LEFT JOIN auth.role role_id ON role_id.id = t.role_id
ORDER BY 2
);
END $function$
*/
}
/**
* @function auth_news_role_u
* @memberof zzglc
* @description Auth news role u
* @param {character_varying} Json
* @returns {integer}
*/
function auth_news_role_u() {
/*
CREATE OR REPLACE FUNCTION zzglc.auth_news_role_u("Json" character varying)
RETURNS integer
LANGUAGE plpgsql
AS $function$
DECLARE v_id integer;
DECLARE json_data json;
BEGIN
json_data := "Json";
v_id := (json_data->>'id')::integer;
UPDATE auth.news_role SET
news_id = (json_data->>'news_id')::integer,
role_id = (json_data->>'role_id')::integer
WHERE id = v_id;
RETURN v_id;
END $function$
*/
}
/**
* @function auth_partner_c
* @memberof zzglc
* @description Auth partner c
* @param {character_varying} Json
* @returns {json}
*/
function auth_partner_c() {
/*
CREATE OR REPLACE FUNCTION zzglc.auth_partner_c("Json" character varying)
RETURNS json
LANGUAGE plpgsql
AS $function$
DECLARE v_id integer;
json_data json;
v_partner_user_id INTEGER;
BEGIN
json_data := "Json";
SELECT p.id INTO v_partner_user_id
FROM auth.person p WHERE p.email = (json_data->>'partner_email')::varchar;
INSERT INTO auth.partner (user_id, partner_email, partner_user_id)
VALUES (auth.get_context_person_id(), (json_data->>'partner_email')::character varying, v_partner_user_id)
RETURNING auth.partner.id INTO v_id;
RETURN json_build_object('id', v_id, 'status', CASE WHEN v_partner_user_id IS NULL THEN 'Not found' ELSE 'OK' END);
END $function$
*/
}
/**
* @function auth_partner_d
* @memberof zzglc
* @description Auth partner d
* @param {integer} Key
* @returns {void}
*/
function auth_partner_d() {
/*
CREATE OR REPLACE FUNCTION zzglc.auth_partner_d("Key" integer)
RETURNS void
LANGUAGE plpgsql
AS $function$
BEGIN
DELETE FROM auth.partner WHERE id = "Key";
END;
$function$
*/
}
/**
* @function auth_partner_r
* @memberof zzglc
* @description Auth partner r
* @returns {Object} integer idcharacter_varying partner_emailtext status
*/
function auth_partner_r() {
/*
CREATE OR REPLACE FUNCTION zzglc.auth_partner_r()
RETURNS TABLE(id integer, partner_email character varying, status text)
LANGUAGE plpgsql
AS $function$
BEGIN
RETURN QUERY (
SELECT t.id,
t.partner_email,
CASE WHEN t.partner_user_id IS NOT NULL THEN 'OK' ELSE 'Unknown user' END status
FROM auth.partner t
WHERE t.user_id = auth.get_context_person_id()
);
END $function$
*/
}
/**
* @function auth_partner_u
* @memberof zzglc
* @description Auth partner u
* @param {character_varying} Json
* @returns {json}
*/
function auth_partner_u() {
/*
CREATE OR REPLACE FUNCTION zzglc.auth_partner_u("Json" character varying)
RETURNS json
LANGUAGE plpgsql
AS $function$
DECLARE json_data json;
DECLARE v_partner_user_id INTEGER;
BEGIN
json_data := "Json";
SELECT p.id INTO v_partner_user_id
FROM auth.person p WHERE p.email = (json_data->>'partner_email')::varchar;
UPDATE auth.partner SET
partner_email = (json_data->>'partner_email')::character varying,
partner_user_id = v_partner_user_id
WHERE id = (json_data->>'id')::integer;
RETURN json_build_object('status', CASE WHEN v_partner_user_id IS NULL THEN 'Not found' ELSE 'OK' END);
END $function$
*/
}
/**
* @function auth_person_c
* @memberof zzglc
* @description Auth person c
* @param {character_varying} Json
* @returns {integer}
*/
function auth_person_c() {
/*
CREATE OR REPLACE FUNCTION zzglc.auth_person_c("Json" character varying)
RETURNS integer
LANGUAGE plpgsql
AS $function$
DECLARE v_id integer;
DECLARE json_data json;
BEGIN
json_data := "Json";
INSERT INTO auth.person (first_name, last_name, partner_id, email, name1, user_email, agreed, nickname)
VALUES ((json_data->>'first_name')::character varying, (json_data->>'last_name')::character varying, (json_data->>'partner_id')::integer, (json_data->>'email')::character varying, (json_data->>'name1')::character varying, (json_data->>'user_email')::character varying, (json_data->>'agreed')::timestamp with time zone, (json_data->>'nickname')::character varying)
RETURNING id INTO v_id;
RETURN v_id;
END $function$
*/
}
/**
* @function auth_person_d
* @memberof zzglc
* @description Auth person d
* @param {integer} Key
* @returns {void}
*/
function auth_person_d() {
/*
CREATE OR REPLACE FUNCTION zzglc.auth_person_d("Key" integer)
RETURNS void
LANGUAGE plpgsql
AS $function$
BEGIN
DELETE FROM auth.person WHERE id = "Key";
END;
$function$
*/
}
/**
* @function auth_person_r
* @memberof zzglc
* @description Auth person r
* @returns {Object} integer idcharacter_varying first_namecharacter_varying last_nameinteger general_partner__partner_idcharacter_varying emailcharacter_varying name1character_varying user_emailtimestamp_with_time_zone agreedcharacter_varying nicknamecharacter_varying general_partner__partner_id_val
*/
function auth_person_r() {
/*
CREATE OR REPLACE FUNCTION zzglc.auth_person_r()
RETURNS TABLE(id integer, first_name character varying, last_name character varying, general_partner__partner_id integer, email character varying, name1 character varying, user_email character varying, agreed timestamp with time zone, nickname character varying, general_partner__partner_id_val character varying)
LANGUAGE plpgsql
AS $function$
BEGIN
RETURN QUERY (
SELECT t.id, t.first_name, t.last_name, t.partner_id, t.email, t.name1, t.user_email, t.agreed, t.nickname, partner_id.short_name
FROM auth.person t
LEFT JOIN general.partner partner_id ON partner_id.id = t.partner_id
ORDER BY 3, 2
);
END $function$
*/
}
/**
* @function auth_person_role_c
* @memberof zzglc
* @description Auth person role c
* @param {character_varying} Json
* @returns {integer}
*/
function auth_person_role_c() {
/*
CREATE OR REPLACE FUNCTION zzglc.auth_person_role_c("Json" character varying)
RETURNS integer
LANGUAGE plpgsql
AS $function$
DECLARE v_id integer;
DECLARE json_data json;
BEGIN
json_data := "Json";
INSERT INTO auth.person_role (person_id, role_id)
VALUES ((json_data->>'person_id')::integer, (json_data->>'role_id')::integer)
RETURNING id INTO v_id;
RETURN v_id;
END $function$
*/
}
/**
* @function auth_person_role_d
* @memberof zzglc
* @description Auth person role d
* @param {integer} Key
* @returns {void}
*/
function auth_person_role_d() {
/*
CREATE OR REPLACE FUNCTION zzglc.auth_person_role_d("Key" integer)
RETURNS void
LANGUAGE plpgsql
AS $function$
BEGIN
DELETE FROM auth.person_role WHERE id = "Key";
END;
$function$
*/
}
/**
* @function auth_person_role_r
* @memberof zzglc
* @description Auth person role r
* @param {integer} Key
* @returns {Object} integer idinteger auth_person__person_idinteger auth_role__role_idcharacter_varying auth_person__person_id_valcharacter_varying auth_role__role_id_val
*/
function auth_person_role_r() {
/*
CREATE OR REPLACE FUNCTION zzglc.auth_person_role_r("Key" integer)
RETURNS TABLE(id integer, auth_person__person_id integer, auth_role__role_id integer, auth_person__person_id_val character varying, auth_role__role_id_val character varying)
LANGUAGE plpgsql
AS $function$
BEGIN
RETURN QUERY (
SELECT t.id, t.person_id, t.role_id, person_id.name, role_id.name
FROM auth.person_role t
LEFT JOIN auth.person person_id ON person_id.id = t.person_id
LEFT JOIN auth.role role_id ON role_id.id = t.role_id
WHERE t.person_id = "Key"
);
END $function$
*/
}
/**
* @function auth_person_role_r_overload
* @overload auth_person_role_r
* @memberof zzglc
* @description Auth person role r
* @returns {Object} integer idinteger auth_person__person_idinteger auth_role__role_idcharacter_varying auth_person__person_id_valcharacter_varying auth_role__role_id_val
*/
function auth_person_role_r_overload() {
/*
CREATE OR REPLACE FUNCTION zzglc.auth_person_role_r()
RETURNS TABLE(id integer, auth_person__person_id integer, auth_role__role_id integer, auth_person__person_id_val character varying, auth_role__role_id_val character varying)
LANGUAGE plpgsql
AS $function$
BEGIN
RETURN QUERY (
SELECT t.id, t.person_id, t.role_id, person_id.name, role_id.name
FROM auth.person_role t
LEFT JOIN auth.person person_id ON person_id.id = t.person_id
LEFT JOIN auth.role role_id ON role_id.id = t.role_id
);
END $function$
*/
}
/**
* @function auth_person_role_u
* @memberof zzglc
* @description Auth person role u
* @param {character_varying} Json
* @returns {void}
*/
function auth_person_role_u() {
/*
CREATE OR REPLACE FUNCTION zzglc.auth_person_role_u("Json" character varying)
RETURNS void
LANGUAGE plpgsql
AS $function$
DECLARE json_data json;
BEGIN
json_data := "Json";
UPDATE auth.person_role SET
person_id = (json_data->>'person_id')::integer,
role_id = (json_data->>'role_id')::integer
WHERE id = (json_data->>'id')::integer;
END $function$
*/
}
/**
* @function auth_person_u
* @memberof zzglc
* @description Auth person u
* @param {character_varying} Json
* @returns {void}
*/
function auth_person_u() {
/*
CREATE OR REPLACE FUNCTION zzglc.auth_person_u("Json" character varying)
RETURNS void
LANGUAGE plpgsql
AS $function$
DECLARE json_data json;
BEGIN
json_data := "Json";
UPDATE auth.person SET
first_name = (json_data->>'first_name')::character varying,
last_name = (json_data->>'last_name')::character varying,
partner_id = (json_data->>'partner_id')::integer,
email = (json_data->>'email')::character varying,
name1 = (json_data->>'name1')::character varying,
user_email = (json_data->>'user_email')::character varying,
agreed = (json_data->>'agreed')::timestamp with time zone,
nickname = (json_data->>'nickname')::character varying
WHERE id = (json_data->>'id')::integer;
END $function$
*/
}
/**
* @function auth_role_c
* @memberof zzglc
* @description Auth role public c
* @param {character_varying} Json
* @returns {integer}
*/
function auth_role_c() {
/*
CREATE OR REPLACE FUNCTION zzglc.auth_role_c("Json" character varying)
RETURNS integer
LANGUAGE plpgsql
AS $function$
DECLARE v_id integer;
BEGIN
INSERT INTO auth.role (
name
)
SELECT
U.name
FROM
json_to_record("Json"::json) U (
name character varying(255)
)
RETURNING id INTO v_id;
RETURN v_id;
END $function$
*/
}
/**
* @function auth_role_d
* @memberof zzglc
* @description Auth role public d
* @param {integer} Key
* @returns {void}
*/
function auth_role_d() {
/*
CREATE OR REPLACE FUNCTION zzglc.auth_role_d("Key" integer)
RETURNS void
LANGUAGE plpgsql
AS $function$
BEGIN
DELETE FROM auth.role
WHERE id = "Key";
END $function$
*/
}
/**
* @function auth_role_r
* @memberof zzglc
* @description Auth role public r
* @returns {Object}
* @property {integer} id
* @property {character_varying} name
*/
function auth_role_r() {
/*
CREATE OR REPLACE FUNCTION zzglc.auth_role_r()
RETURNS TABLE(id integer, name character varying)
LANGUAGE plpgsql
AS $function$
BEGIN
RETURN QUERY
SELECT
t.id, t.name
FROM auth.role t
ORDER BY t.name
;
END $function$
*/
}
/**
* @function auth_role_u
* @memberof zzglc
* @description Auth role public u
* @param {character_varying} Json
* @returns {void}
*/
function auth_role_u() {
/*
CREATE OR REPLACE FUNCTION zzglc.auth_role_u("Json" character varying)
RETURNS void
LANGUAGE plpgsql
AS $function$
DECLARE v_row_count INTEGER;
BEGIN
UPDATE auth.role t
SET name = U.name
FROM json_to_record("Json"::json) AS U (
id integer,
name character varying(255)
)
WHERE U.id = t.id
;
END $function$
*/
}
/**
* @function auth_route_role_c
* @memberof zzglc
* @description Auth route role c
* @param {character_varying} Json
* @returns {integer}
*/
function auth_route_role_c() {
/*
CREATE OR REPLACE FUNCTION zzglc.auth_route_role_c("Json" character varying)
RETURNS integer
LANGUAGE plpgsql
AS $function$
DECLARE v_id integer;
DECLARE json_data json;
BEGIN
json_data := "Json";
INSERT INTO auth.route_role (route_id, role_id, read_only)
VALUES ((json_data->>'route_id')::integer, (json_data->>'role_id')::integer, (json_data->>'read_only')::boolean)
RETURNING id INTO v_id;
RETURN v_id;
END $function$
*/
}
/**
* @function auth_route_role_d
* @memberof zzglc
* @description Auth route role d
* @param {integer} Key
* @returns {void}
*/
function auth_route_role_d() {
/*
CREATE OR REPLACE FUNCTION zzglc.auth_route_role_d("Key" integer)
RETURNS void
LANGUAGE plpgsql
AS $function$
BEGIN
DELETE FROM auth.route_role WHERE id = "Key";
END;
$function$
*/
}
/**
* @function auth_route_role_r
* @memberof zzglc
* @description Auth route role r
* @param {integer} Key
* @returns {Object} integer idinteger auth_route__route_idinteger auth_role__role_idboolean read_onlycharacter_varying auth_route__route_id_valcharacter_varying auth_role__role_id_val
*/
function auth_route_role_r() {
/*
CREATE OR REPLACE FUNCTION zzglc.auth_route_role_r("Key" integer)
RETURNS TABLE(id integer, auth_route__route_id integer, auth_role__role_id integer, read_only boolean, auth_route__route_id_val character varying, auth_role__role_id_val character varying)
LANGUAGE plpgsql
AS $function$
BEGIN
RETURN QUERY (
SELECT t.id, t.route_id, t.role_id, t.read_only, route_id.name, role_id.name
FROM auth.route_role t
LEFT JOIN meta.route route_id ON route_id.id = t.route_id
LEFT JOIN auth.role role_id ON role_id.id = t.role_id
WHERE t.route_id = "Key"
);
END $function$
*/
}
/**
* @function auth_route_role_r_overload
* @overload auth_route_role_r
* @memberof zzglc
* @description Auth route role r
* @returns {Object} integer idinteger auth_route__route_idinteger auth_role__role_idboolean read_onlycharacter_varying auth_route__route_id_valcharacter_varying auth_role__role_id_val
*/
function auth_route_role_r_overload() {
/*
CREATE OR REPLACE FUNCTION zzglc.auth_route_role_r()
RETURNS TABLE(id integer, auth_route__route_id integer, auth_role__role_id integer, read_only boolean, auth_route__route_id_val character varying, auth_role__role_id_val character varying)
LANGUAGE plpgsql
AS $function$
BEGIN
RETURN QUERY (
SELECT t.id, t.route_id, t.role_id, t.read_only, route_id.name, role_id.name
FROM auth.route_role t
LEFT JOIN meta.route route_id ON route_id.id = t.route_id
LEFT JOIN auth.role role_id ON role_id.id = t.role_id
);
END $function$
*/
}
/**
* @function auth_route_role_u
* @memberof zzglc
* @description Auth route role u
* @param {character_varying} Json
* @returns {void}
*/
function auth_route_role_u() {
/*
CREATE OR REPLACE FUNCTION zzglc.auth_route_role_u("Json" character varying)
RETURNS void
LANGUAGE plpgsql
AS $function$
DECLARE json_data json;
BEGIN
json_data := "Json";
UPDATE auth.route_role rr SET
route_id = (json_data->>'route_id')::integer,
role_id = (json_data->>'role_id')::integer,
read_only = (json_data->>'read_only')::boolean
WHERE id = (json_data->>'id')::integer;
END $function$
*/
}
/**
* @function auth_user_role_c
* @memberof zzglc
* @description Auth user role c
* @param {character_varying} Json
* @returns {void}
*/
function auth_user_role_c() {
/*
CREATE OR REPLACE FUNCTION zzglc.auth_user_role_c("Json" character varying)
RETURNS void
LANGUAGE plpgsql
AS $function$
BEGIN
INSERT INTO auth.user_role (
user_id,
role_id
)
SELECT
U.user_id,
U.role_id
FROM
json_to_record("Json"::json) U (
user_id uuid,
role_id uuid
)
;
END $function$
*/
}
/**
* @function auth_user_role_d
* @memberof zzglc
* @description Auth user role d
* @param {uuid} Key
* @returns {void}
*/
function auth_user_role_d() {
/*
CREATE OR REPLACE FUNCTION zzglc.auth_user_role_d("Key" uuid)
RETURNS void
LANGUAGE plpgsql
AS $function$
BEGIN
DELETE FROM auth.user_role
WHERE id = "Key";
END $function$
*/
}
/**
* @function auth_user_role_r
* @memberof zzglc
* @description Auth user role r
* @returns {Object}
* @property {uuid} id
* @property {uuid} user_id
* @property {uuid} role_id
* @property {timestamp_without_time_zone} time_modified
*/
function auth_user_role_r() {
/*
CREATE OR REPLACE FUNCTION zzglc.auth_user_role_r()
RETURNS TABLE(id uuid, user_id uuid, role_id uuid, time_modified timestamp without time zone)
LANGUAGE plpgsql
AS $function$
BEGIN
RETURN QUERY
SELECT
t.id, t.user_id, t.role_id, t.time_modified
FROM auth.user_role t
ORDER BY t.user_id
;
END $function$
*/
}
/**
* @function auth_user_role_u
* @memberof zzglc
* @description Auth user role u
* @param {character_varying} Json
* @returns {void}
*/
function auth_user_role_u() {
/*
CREATE OR REPLACE FUNCTION zzglc.auth_user_role_u("Json" character varying)
RETURNS void
LANGUAGE plpgsql
AS $function$
DECLARE v_row_count INTEGER;
BEGIN
UPDATE auth.user_role t
SET user_id = U.user_id,
role_id = U.role_id
FROM json_to_record("Json"::json) AS U (
id uuid,
user_id uuid,
role_id uuid,
time_modified timestamp without time zone
)
WHERE U.id = t.id
AND t.time_modified = U.time_modified;
GET DIAGNOSTICS v_row_count = ROW_COUNT;
IF v_row_count = 0 THEN
SELECT meta.raise_error(2);
END IF
;
END $function$
*/
}
/**
* @function catalog_accession_c
* @memberof zzglc
* @description Catalog accession c
* @param {character_varying} Json
* @returns {integer}
*/
function catalog_accession_c() {
/*
CREATE OR REPLACE FUNCTION zzglc.catalog_accession_c("Json" character varying)
RETURNS integer
LANGUAGE plpgsql
AS $function$
DECLARE v_id integer;
DECLARE json_data json;
BEGIN
json_data := "Json";
INSERT INTO catalog.accession (name, url)
VALUES ((json_data->>'name')::character varying, (json_data->>'url')::character varying)
RETURNING id INTO v_id;
RETURN v_id;
END $function$
*/
}
/**
* @function catalog_accession_d
* @memberof zzglc
* @description Catalog accession d
* @param {integer} Key
* @returns {void}
*/
function catalog_accession_d() {
/*
CREATE OR REPLACE FUNCTION zzglc.catalog_accession_d("Key" integer)
RETURNS void
LANGUAGE plpgsql
AS $function$
BEGIN
DELETE FROM catalog.accession WHERE id = "Key";
END;
$function$
*/
}
/**
* @function catalog_accession_r
* @memberof zzglc
* @description Catalog accession r
* @returns {Object} integer idcharacter_varying namecharacter_varying url
*/
function catalog_accession_r() {
/*
CREATE OR REPLACE FUNCTION zzglc.catalog_accession_r()
RETURNS TABLE(id integer, name character varying, url character varying)
LANGUAGE plpgsql
AS $function$
BEGIN
RETURN QUERY (
SELECT t.id, t.name, t.url
FROM catalog.accession t
ORDER BY 2
);
END $function$
*/
}
/**
* @function catalog_accession_u
* @memberof zzglc
* @description Catalog accession u
* @param {character_varying} Json
* @returns {void}
*/
function catalog_accession_u() {
/*
CREATE OR REPLACE FUNCTION zzglc.catalog_accession_u("Json" character varying)
RETURNS void
LANGUAGE plpgsql
AS $function$
DECLARE json_data json;
BEGIN
json_data := "Json";
UPDATE catalog.accession SET
name = (json_data->>'name')::character varying,
url = (json_data->>'url')::character varying
WHERE id = (json_data->>'id')::integer;
END $function$
*/
}
/**
* @function catalog_aggregate_stability_app_c
* @memberof zzglc
* @description Catalog aggregate stability app c
* @param {character_varying} Json
* @returns {integer}
*/
function catalog_aggregate_stability_app_c() {
/*
CREATE OR REPLACE FUNCTION zzglc.catalog_aggregate_stability_app_c("Json" character varying)
RETURNS integer
LANGUAGE plpgsql
AS $function$
DECLARE v_id integer;
DECLARE json_data json;
BEGIN
json_data := "Json";
INSERT INTO catalog.aggregate_stability_app (name, version)
VALUES ((json_data->>'name')::character varying, (json_data->>'version')::character varying)
RETURNING id INTO v_id;
RETURN v_id;
END $function$
*/
}
/**
* @function catalog_aggregate_stability_app_d
* @memberof zzglc
* @description Catalog aggregate stability app d
* @param {integer} Key
* @returns {void}
*/
function catalog_aggregate_stability_app_d() {
/*
CREATE OR REPLACE FUNCTION zzglc.catalog_aggregate_stability_app_d("Key" integer)
RETURNS void
LANGUAGE plpgsql
AS $function$
BEGIN
DELETE FROM catalog.aggregate_stability_app WHERE id = "Key";
END;
$function$
*/
}
/**
* @function catalog_aggregate_stability_app_r
* @memberof zzglc
* @description Catalog aggregate stability app r
* @returns {Object} integer idcharacter_varying namecharacter_varying version
*/
function catalog_aggregate_stability_app_r() {
/*
CREATE OR REPLACE FUNCTION zzglc.catalog_aggregate_stability_app_r()
RETURNS TABLE(id integer, name character varying, version character varying)
LANGUAGE plpgsql
AS $function$
BEGIN
RETURN QUERY (
SELECT t.id, t.name, t.version
FROM catalog.aggregate_stability_app t
ORDER BY 2
);
END $function$
*/
}
/**
* @function catalog_aggregate_stability_app_u
* @memberof zzglc
* @description Catalog aggregate stability app u
* @param {character_varying} Json
* @returns {integer}
*/
function catalog_aggregate_stability_app_u() {
/*
CREATE OR REPLACE FUNCTION zzglc.catalog_aggregate_stability_app_u("Json" character varying)
RETURNS integer
LANGUAGE plpgsql
AS $function$
DECLARE v_id integer;
DECLARE json_data json;
BEGIN
json_data := "Json";
v_id := (json_data->>'id')::integer;
UPDATE catalog.aggregate_stability_app SET
name = (json_data->>'name')::character varying,
version = (json_data->>'version')::character varying
WHERE id = v_id;
RETURN v_id;
END $function$
*/
}
/**
* @function catalog_application_c
* @memberof zzglc
* @description Catalog application c
* @param {character_varying} Json
* @returns {integer}
*/
function catalog_application_c() {
/*
CREATE OR REPLACE FUNCTION zzglc.catalog_application_c("Json" character varying)
RETURNS integer
LANGUAGE plpgsql
AS $function$
DECLARE v_id integer;
DECLARE json_data json;
BEGIN
json_data := "Json";
INSERT INTO catalog.application (name)
VALUES ((json_data->>'name')::character varying)
RETURNING id INTO v_id;
RETURN v_id;
END $function$
*/
}
/**
* @function catalog_application_d
* @memberof zzglc
* @description Catalog application d
* @param {integer} Key
* @returns {void}
*/
function catalog_application_d() {
/*
CREATE OR REPLACE FUNCTION zzglc.catalog_application_d("Key" integer)
RETURNS void
LANGUAGE plpgsql
AS $function$
BEGIN
DELETE FROM catalog.application WHERE id = "Key";
END;
$function$
*/
}
/**
* @function catalog_application_r
* @memberof zzglc
* @description Catalog application r
* @returns {Object} integer idcharacter_varying name
*/
function catalog_application_r() {
/*
CREATE OR REPLACE FUNCTION zzglc.catalog_application_r()
RETURNS TABLE(id integer, name character varying)
LANGUAGE plpgsql
AS $function$
BEGIN
RETURN QUERY (
SELECT t.id, t.name
FROM catalog.application t
ORDER BY 2
);
END $function$
*/
}
/**
* @function catalog_application_u
* @memberof zzglc
* @description Catalog application u
* @param {character_varying} Json
* @returns {integer}
*/
function catalog_application_u() {
/*
CREATE OR REPLACE FUNCTION zzglc.catalog_application_u("Json" character varying)
RETURNS integer
LANGUAGE plpgsql
AS $function$
DECLARE v_id integer;
DECLARE json_data json;
BEGIN
json_data := "Json";
v_id := (json_data->>'id')::integer;
UPDATE catalog.application SET
name = (json_data->>'name')::character varying
WHERE id = v_id;
RETURN v_id;
END $function$
*/
}
/**
* @function catalog_asset_catalog_c
* @memberof zzglc
* @description Catalog asset catalog c
* @param {character_varying} Json
* @returns {integer}
*/
function catalog_asset_catalog_c() {
/*
CREATE OR REPLACE FUNCTION zzglc.catalog_asset_catalog_c("Json" character varying)
RETURNS integer
LANGUAGE plpgsql
AS $function$
DECLARE v_id integer;
DECLARE json_data json;
BEGIN
json_data := "Json";
INSERT INTO catalog.asset_catalog (name)
VALUES ((json_data->>'name')::character varying)
RETURNING id INTO v_id;
RETURN v_id;
END $function$
*/
}
/**
* @function catalog_asset_catalog_d
* @memberof zzglc
* @description Catalog asset catalog d
* @param {integer} Key
* @returns {void}
*/
function catalog_asset_catalog_d() {
/*
CREATE OR REPLACE FUNCTION zzglc.catalog_asset_catalog_d("Key" integer)
RETURNS void
LANGUAGE plpgsql
AS $function$
BEGIN
DELETE FROM catalog.asset_catalog WHERE id = "Key";
END;
$function$
*/
}
/**
* @function catalog_asset_catalog_r
* @memberof zzglc
* @description Catalog asset catalog r
* @returns {Object} integer idcharacter_varying name
*/
function catalog_asset_catalog_r() {
/*
CREATE OR REPLACE FUNCTION zzglc.catalog_asset_catalog_r()
RETURNS TABLE(id integer, name character varying)
LANGUAGE plpgsql
AS $function$
BEGIN
RETURN QUERY (
SELECT t.id, t.name
FROM catalog.asset_catalog t
ORDER BY 2
);
END $function$
*/
}
/**
* @function catalog_asset_catalog_u
* @memberof zzglc
* @description Catalog asset catalog u
* @param {character_varying} Json
* @returns {integer}
*/
function catalog_asset_catalog_u() {
/*
CREATE OR REPLACE FUNCTION zzglc.catalog_asset_catalog_u("Json" character varying)
RETURNS integer
LANGUAGE plpgsql
AS $function$
DECLARE v_id integer;
DECLARE json_data json;
BEGIN
json_data := "Json";
v_id := (json_data->>'id')::integer;
UPDATE catalog.asset_catalog SET
name = (json_data->>'name')::character varying
WHERE id = v_id;
RETURN v_id;
END $function$
*/
}
/**
* @function catalog_asset_theme_c
* @memberof zzglc
* @description Catalog asset theme c
* @param {character_varying} Json
* @returns {integer}
*/
function catalog_asset_theme_c() {
/*
CREATE OR REPLACE FUNCTION zzglc.catalog_asset_theme_c("Json" character varying)
RETURNS integer
LANGUAGE plpgsql
AS $function$
DECLARE v_id integer;
DECLARE json_data json;
BEGIN
json_data := "Json";
INSERT INTO catalog.asset_theme (name)
VALUES ((json_data->>'name')::character varying)
RETURNING id INTO v_id;
RETURN v_id;
END $function$
*/
}
/**
* @function catalog_asset_theme_d
* @memberof zzglc
* @description Catalog asset theme d
* @param {integer} Key
* @returns {void}
*/
function catalog_asset_theme_d() {
/*
CREATE OR REPLACE FUNCTION zzglc.catalog_asset_theme_d("Key" integer)
RETURNS void
LANGUAGE plpgsql
AS $function$
BEGIN
DELETE FROM catalog.asset_theme WHERE id = "Key";
END;
$function$
*/
}
/**
* @function catalog_asset_theme_r
* @memberof zzglc
* @description Catalog asset theme r
* @returns {Object} integer idcharacter_varying name
*/
function catalog_asset_theme_r() {
/*
CREATE OR REPLACE FUNCTION zzglc.catalog_asset_theme_r()
RETURNS TABLE(id integer, name character varying)
LANGUAGE plpgsql
AS $function$
BEGIN
RETURN QUERY (
SELECT t.id, t.name
FROM catalog.asset_theme t
ORDER BY 2
);
END $function$
*/
}
/**
* @function catalog_asset_theme_u
* @memberof zzglc
* @description Catalog asset theme u
* @param {character_varying} Json
* @returns {integer}
*/
function catalog_asset_theme_u() {
/*
CREATE OR REPLACE FUNCTION zzglc.catalog_asset_theme_u("Json" character varying)
RETURNS integer
LANGUAGE plpgsql
AS $function$
DECLARE v_id integer;
DECLARE json_data json;
BEGIN
json_data := "Json";
v_id := (json_data->>'id')::integer;
UPDATE catalog.asset_theme SET
name = (json_data->>'name')::character varying
WHERE id = v_id;
RETURN v_id;
END $function$
*/
}
/**
* @function catalog_asset_version_c
* @memberof zzglc
* @description Data asset version c
* @param {character_varying} Json
* @returns {void}
*/
function catalog_asset_version_c() {
/*
CREATE OR REPLACE FUNCTION zzglc.catalog_asset_version_c("Json" character varying)
RETURNS void
LANGUAGE plpgsql
AS $function$
BEGIN
INSERT INTO catalog.asset_version (
name,
srid
)
SELECT
U.name,
U.srid
FROM
json_to_record("Json"::json) U (
name character varying,
srid character varying
)
;
END $function$
*/
}
/**
* @function catalog_asset_version_d
* @memberof zzglc
* @description Data asset version d
* @param {integer} Key
* @returns {void}
*/
function catalog_asset_version_d() {
/*
CREATE OR REPLACE FUNCTION zzglc.catalog_asset_version_d("Key" integer)
RETURNS void
LANGUAGE plpgsql
AS $function$
BEGIN
DELETE FROM data.asset_version
WHERE id = "Key";
END $function$
*/
}
/**
* @function catalog_asset_version_r
* @memberof zzglc
* @description Data asset version r
* @returns {Object}
* @property {integer} id
* @property {character_varying} name
* @property {character_varying} srid
*/
function catalog_asset_version_r() {
/*
CREATE OR REPLACE FUNCTION zzglc.catalog_asset_version_r()
RETURNS TABLE(id integer, name character varying, srid character varying)
LANGUAGE plpgsql
AS $function$
BEGIN
RETURN QUERY
SELECT
t.id, t.name, t.srid
FROM catalog.asset_version t
ORDER BY t.name
;
END $function$
*/
}
/**
* @function catalog_asset_version_u
* @memberof zzglc
* @description Data asset version u
* @param {character_varying} Json
* @returns {void}
*/
function catalog_asset_version_u() {
/*
CREATE OR REPLACE FUNCTION zzglc.catalog_asset_version_u("Json" character varying)
RETURNS void
LANGUAGE plpgsql
AS $function$
DECLARE v_row_count INTEGER;
BEGIN
UPDATE catalog.asset_version t
SET name = U.name,
srid = U.srid
FROM json_to_record("Json"::json) AS U (
id integer,
name character varying,
srid character varying
)
WHERE U.id = t.id
;
END $function$
*/
}
/**
* @function catalog_brand_c
* @memberof zzglc
* @description Catalog brand c
* @param {character_varying} Json
* @returns {integer}
*/
function catalog_brand_c() {
/*
CREATE OR REPLACE FUNCTION zzglc.catalog_brand_c("Json" character varying)
RETURNS integer
LANGUAGE plpgsql
AS $function$
DECLARE v_id integer;
DECLARE json_data json;
BEGIN
json_data := "Json";
INSERT INTO catalog.brand (name)
VALUES ((json_data->>'name')::character varying)
RETURNING id INTO v_id;
RETURN v_id;
END $function$
*/
}
/**
* @function catalog_brand_d
* @memberof zzglc
* @description Catalog brand d
* @param {integer} Key
* @returns {void}
*/
function catalog_brand_d() {
/*
CREATE OR REPLACE FUNCTION zzglc.catalog_brand_d("Key" integer)
RETURNS void
LANGUAGE plpgsql
AS $function$
BEGIN
DELETE FROM catalog.brand WHERE id = "Key";
END;
$function$
*/
}
/**
* @function catalog_brand_r
* @memberof zzglc
* @description Catalog brand r
* @returns {Object} integer idcharacter_varying name
*/
function catalog_brand_r() {
/*
CREATE OR REPLACE FUNCTION zzglc.catalog_brand_r()
RETURNS TABLE(id integer, name character varying)
LANGUAGE plpgsql
AS $function$
BEGIN
RETURN QUERY (
SELECT t.id, t.name
FROM catalog.brand t
ORDER BY 2
);
END $function$
*/
}
/**
* @function catalog_brand_u
* @memberof zzglc
* @description Catalog brand u
* @param {character_varying} Json
* @returns {void}
*/
function catalog_brand_u() {
/*
CREATE OR REPLACE FUNCTION zzglc.catalog_brand_u("Json" character varying)
RETURNS void
LANGUAGE plpgsql
AS $function$
DECLARE json_data json;
BEGIN
json_data := "Json";
UPDATE catalog.brand SET
name = (json_data->>'name')::character varying
WHERE id = (json_data->>'id')::integer;
END $function$
*/
}
/**
* @function catalog_crop_c
* @memberof zzglc
* @description Catalog crop c
* @param {character_varying} Json
* @returns {integer}
*/
function catalog_crop_c() {
/*
CREATE OR REPLACE FUNCTION zzglc.catalog_crop_c("Json" character varying)
RETURNS integer
LANGUAGE plpgsql
AS $function$
DECLARE v_id integer;
DECLARE json_data json;
BEGIN
json_data := "Json";
INSERT INTO catalog.crop (name)
VALUES ((json_data->>'name')::character varying)
RETURNING id INTO v_id;
RETURN v_id;
END $function$
*/
}
/**
* @function catalog_crop_d
* @memberof zzglc
* @description Catalog crop d
* @param {integer} Key
* @returns {void}
*/
function catalog_crop_d() {
/*
CREATE OR REPLACE FUNCTION zzglc.catalog_crop_d("Key" integer)
RETURNS void
LANGUAGE plpgsql
AS $function$
BEGIN
DELETE FROM catalog.crop WHERE id = "Key";
END;
$function$
*/
}
/**
* @function catalog_crop_growth_stage_c
* @memberof zzglc
* @description Catalog crop growth stage c
* @param {character_varying} Json
* @returns {integer}
*/
function catalog_crop_growth_stage_c() {
/*
CREATE OR REPLACE FUNCTION zzglc.catalog_crop_growth_stage_c("Json" character varying)
RETURNS integer
LANGUAGE plpgsql
AS $function$
DECLARE v_id integer;
DECLARE json_data json;
BEGIN
json_data := "Json";
INSERT INTO catalog.crop_growth_stage (name)
VALUES ((json_data->>'name')::character varying)
RETURNING id INTO v_id;
RETURN v_id;
END $function$
*/
}
/**
* @function catalog_crop_growth_stage_d
* @memberof zzglc
* @description Catalog crop growth stage d
* @param {integer} Key
* @returns {void}
*/
function catalog_crop_growth_stage_d() {
/*
CREATE OR REPLACE FUNCTION zzglc.catalog_crop_growth_stage_d("Key" integer)
RETURNS void
LANGUAGE plpgsql
AS $function$
BEGIN
DELETE FROM catalog.crop_growth_stage WHERE id = "Key";
END;
$function$
*/
}
/**
* @function catalog_crop_growth_stage_r
* @memberof zzglc
* @description Catalog crop growth stage r
* @returns {Object} integer idcharacter_varying name
*/
function catalog_crop_growth_stage_r() {
/*
CREATE OR REPLACE FUNCTION zzglc.catalog_crop_growth_stage_r()
RETURNS TABLE(id integer, name character varying)
LANGUAGE plpgsql
AS $function$
BEGIN
RETURN QUERY (
SELECT t.id, t.name
FROM catalog.crop_growth_stage t
ORDER BY 2
);
END $function$
*/
}
/**
* @function catalog_crop_growth_stage_u
* @memberof zzglc
* @description Catalog crop growth stage u
* @param {character_varying} Json
* @returns {integer}
*/
function catalog_crop_growth_stage_u() {
/*
CREATE OR REPLACE FUNCTION zzglc.catalog_crop_growth_stage_u("Json" character varying)
RETURNS integer
LANGUAGE plpgsql
AS $function$
DECLARE v_id integer;
DECLARE json_data json;
BEGIN
json_data := "Json";
v_id := (json_data->>'id')::integer;
UPDATE catalog.crop_growth_stage SET
name = (json_data->>'name')::character varying
WHERE id = v_id;
RETURN v_id;
END $function$
*/
}
/**
* @function catalog_crop_r
* @memberof zzglc
* @description Catalog crop r
* @returns {Object} integer idcharacter_varying name
*/
function catalog_crop_r() {
/*
CREATE OR REPLACE FUNCTION zzglc.catalog_crop_r()
RETURNS TABLE(id integer, name character varying)
LANGUAGE plpgsql
AS $function$
BEGIN
RETURN QUERY (
SELECT t.id, t.name
FROM catalog.crop t
ORDER BY 2
);
END $function$
*/
}
/**
* @function catalog_crop_u
* @memberof zzglc
* @description Catalog crop u
* @param {character_varying} Json
* @returns {integer}
*/
function catalog_crop_u() {
/*
CREATE OR REPLACE FUNCTION zzglc.catalog_crop_u("Json" character varying)
RETURNS integer
LANGUAGE plpgsql
AS $function$
DECLARE v_id integer;
DECLARE json_data json;
BEGIN
json_data := "Json";
v_id := (json_data->>'id')::integer;
UPDATE catalog.crop SET
name = (json_data->>'name')::character varying
WHERE id = v_id;
RETURN v_id;
END $function$
*/
}
/**
* @function catalog_date_style_c
* @memberof zzglc
* @description Catalog date style c
* @param {character_varying} Json
* @returns {integer}
*/
function catalog_date_style_c() {
/*
CREATE OR REPLACE FUNCTION zzglc.catalog_date_style_c("Json" character varying)
RETURNS integer
LANGUAGE plpgsql
AS $function$
DECLARE v_id integer;
DECLARE json_data json;
BEGIN
json_data := "Json";
INSERT INTO catalog.date_style (name)
VALUES ((json_data->>'name')::character varying)
RETURNING id INTO v_id;
RETURN v_id;
END $function$
*/
}
/**
* @function catalog_date_style_d
* @memberof zzglc
* @description Catalog date style d
* @param {integer} Key
* @returns {void}
*/
function catalog_date_style_d() {
/*
CREATE OR REPLACE FUNCTION zzglc.catalog_date_style_d("Key" integer)
RETURNS void
LANGUAGE plpgsql
AS $function$
BEGIN
DELETE FROM catalog.date_style WHERE id = "Key";
END;
$function$
*/
}
/**
* @function catalog_date_style_r
* @memberof zzglc
* @description Catalog date style r
* @returns {Object} integer idcharacter_varying name
*/
function catalog_date_style_r() {
/*
CREATE OR REPLACE FUNCTION zzglc.catalog_date_style_r()
RETURNS TABLE(id integer, name character varying)
LANGUAGE plpgsql
AS $function$
BEGIN
RETURN QUERY (
SELECT t.id, t.name
FROM catalog.date_style t
ORDER BY 2
);
END $function$
*/
}
/**
* @function catalog_date_style_u
* @memberof zzglc
* @description Catalog date style u
* @param {character_varying} Json
* @returns {integer}
*/
function catalog_date_style_u() {
/*
CREATE OR REPLACE FUNCTION zzglc.catalog_date_style_u("Json" character varying)
RETURNS integer
LANGUAGE plpgsql
AS $function$
DECLARE v_id integer;
DECLARE json_data json;
BEGIN
json_data := "Json";
v_id := (json_data->>'id')::integer;
UPDATE catalog.date_style SET
name = (json_data->>'name')::character varying
WHERE id = v_id;
RETURN v_id;
END $function$
*/
}
/**
* @function catalog_date_unit_c
* @memberof zzglc
* @description Catalog date unit c
* @param {character_varying} Json
* @returns {integer}
*/
function catalog_date_unit_c() {
/*
CREATE OR REPLACE FUNCTION zzglc.catalog_date_unit_c("Json" character varying)
RETURNS integer
LANGUAGE plpgsql
AS $function$
DECLARE v_id integer;
DECLARE json_data json;
BEGIN
json_data := "Json";
INSERT INTO catalog.date_unit (name, format)
VALUES ((json_data->>'name')::character varying, (json_data->>'format')::character varying)
RETURNING id INTO v_id;
RETURN v_id;
END $function$
*/
}
/**
* @function catalog_date_unit_d
* @memberof zzglc
* @description Catalog date unit d
* @param {integer} Key
* @returns {void}
*/
function catalog_date_unit_d() {
/*
CREATE OR REPLACE FUNCTION zzglc.catalog_date_unit_d("Key" integer)
RETURNS void
LANGUAGE plpgsql
AS $function$
BEGIN
DELETE FROM catalog.date_unit WHERE id = "Key";
END;
$function$
*/
}
/**
* @function catalog_date_unit_r
* @memberof zzglc
* @description Catalog date unit r
* @returns {Object} integer idcharacter_varying namecharacter_varying format
*/
function catalog_date_unit_r() {
/*
CREATE OR REPLACE FUNCTION zzglc.catalog_date_unit_r()
RETURNS TABLE(id integer, name character varying, format character varying)
LANGUAGE plpgsql
AS $function$
BEGIN
RETURN QUERY (
SELECT t.id, t.name, t.format
FROM catalog.date_unit t
ORDER BY 2
);
END $function$
*/
}
/**
* @function catalog_date_unit_u
* @memberof zzglc
* @description Catalog date unit u
* @param {character_varying} Json
* @returns {integer}
*/
function catalog_date_unit_u() {
/*
CREATE OR REPLACE FUNCTION zzglc.catalog_date_unit_u("Json" character varying)
RETURNS integer
LANGUAGE plpgsql
AS $function$
DECLARE v_id integer;
DECLARE json_data json;
BEGIN
json_data := "Json";
v_id := (json_data->>'id')::integer;
UPDATE catalog.date_unit SET
name = (json_data->>'name')::character varying,
format = (json_data->>'format')::character varying
WHERE id = v_id;
RETURN v_id;
END $function$
*/
}
/**
* @function catalog_direction_c
* @memberof zzglc
* @description Catalog direction c
* @param {character_varying} Json
* @returns {integer}
*/
function catalog_direction_c() {
/*
CREATE OR REPLACE FUNCTION zzglc.catalog_direction_c("Json" character varying)
RETURNS integer
LANGUAGE plpgsql
AS $function$
DECLARE v_id integer;
DECLARE json_data json;
BEGIN
json_data := "Json";
INSERT INTO catalog.direction (name)
VALUES ((json_data->>'name')::character varying)
RETURNING id INTO v_id;
RETURN v_id;
END $function$
*/
}
/**
* @function catalog_direction_d
* @memberof zzglc
* @description Catalog direction d
* @param {integer} Key
* @returns {void}
*/
function catalog_direction_d() {
/*
CREATE OR REPLACE FUNCTION zzglc.catalog_direction_d("Key" integer)
RETURNS void
LANGUAGE plpgsql
AS $function$
BEGIN
DELETE FROM catalog.direction WHERE id = "Key";
END;
$function$
*/
}
/**
* @function catalog_direction_r
* @memberof zzglc
* @description Catalog direction r
* @returns {Object} integer idcharacter_varying name
*/
function catalog_direction_r() {
/*
CREATE OR REPLACE FUNCTION zzglc.catalog_direction_r()
RETURNS TABLE(id integer, name character varying)
LANGUAGE plpgsql
AS $function$
BEGIN
RETURN QUERY (
SELECT t.id, t.name
FROM catalog.direction t
ORDER BY 2
);
END $function$
*/
}
/**
* @function catalog_direction_u
* @memberof zzglc
* @description Catalog direction u
* @param {character_varying} Json
* @returns {integer}
*/
function catalog_direction_u() {
/*
CREATE OR REPLACE FUNCTION zzglc.catalog_direction_u("Json" character varying)
RETURNS integer
LANGUAGE plpgsql
AS $function$
DECLARE v_id integer;
DECLARE json_data json;
BEGIN
json_data := "Json";
v_id := (json_data->>'id')::integer;
UPDATE catalog.direction SET
name = (json_data->>'name')::character varying
WHERE id = v_id;
RETURN v_id;
END $function$
*/
}
/**
* @function catalog_enzyme_type_c
* @memberof zzglc
* @description Catalog enzyme type c
* @param {character_varying} Json
* @returns {integer}
*/
function catalog_enzyme_type_c() {
/*
CREATE OR REPLACE FUNCTION zzglc.catalog_enzyme_type_c("Json" character varying)
RETURNS integer
LANGUAGE plpgsql
AS $function$
DECLARE v_id integer;
DECLARE json_data json;
BEGIN
json_data := "Json";
INSERT INTO catalog.enzyme_type (name, code)
VALUES ((json_data->>'name')::character varying, (json_data->>'code')::character varying)
RETURNING id INTO v_id;
RETURN v_id;
END $function$
*/
}
/**
* @function catalog_enzyme_type_d
* @memberof zzglc
* @description Catalog enzyme type d
* @param {integer} Key
* @returns {void}
*/
function catalog_enzyme_type_d() {
/*
CREATE OR REPLACE FUNCTION zzglc.catalog_enzyme_type_d("Key" integer)
RETURNS void
LANGUAGE plpgsql
AS $function$
BEGIN
DELETE FROM catalog.enzyme_type WHERE id = "Key";
END;
$function$
*/
}
/**
* @function catalog_enzyme_type_r
* @memberof zzglc
* @description Catalog enzyme type r
* @returns {Object} integer idcharacter_varying namecharacter_varying code
*/
function catalog_enzyme_type_r() {
/*
CREATE OR REPLACE FUNCTION zzglc.catalog_enzyme_type_r()
RETURNS TABLE(id integer, name character varying, code character varying)
LANGUAGE plpgsql
AS $function$
BEGIN
RETURN QUERY (
SELECT t.id, t.name, t.code
FROM catalog.enzyme_type t
ORDER BY 2
);
END $function$
*/
}
/**
* @function catalog_enzyme_type_u
* @memberof zzglc
* @description Catalog enzyme type u
* @param {character_varying} Json
* @returns {void}
*/
function catalog_enzyme_type_u() {
/*
CREATE OR REPLACE FUNCTION zzglc.catalog_enzyme_type_u("Json" character varying)
RETURNS void
LANGUAGE plpgsql
AS $function$
DECLARE json_data json;
BEGIN
json_data := "Json";
UPDATE catalog.enzyme_type SET
name = (json_data->>'name')::character varying,
code = (json_data->>'code')::character varying
WHERE id = (json_data->>'id')::integer;
END $function$
*/
}
/**
* @function catalog_equipment_type_c
* @memberof zzglc
* @description Catalog equipment type c
* @param {character_varying} Json
* @returns {integer}
*/
function catalog_equipment_type_c() {
/*
CREATE OR REPLACE FUNCTION zzglc.catalog_equipment_type_c("Json" character varying)
RETURNS integer
LANGUAGE plpgsql
AS $function$
DECLARE v_id integer;
DECLARE json_data json;
BEGIN
json_data := "Json";
INSERT INTO catalog.equipment_type (name, application_id, observation_type_id)
VALUES ((json_data->>'name')::character varying, (json_data->>'application_id')::integer, (json_data->>'observation_type_id')::integer)
RETURNING id INTO v_id;
RETURN v_id;
END $function$
*/
}
/**
* @function catalog_equipment_type_d
* @memberof zzglc
* @description Catalog equipment type d
* @param {integer} Key
* @returns {void}
*/
function catalog_equipment_type_d() {
/*
CREATE OR REPLACE FUNCTION zzglc.catalog_equipment_type_d("Key" integer)
RETURNS void
LANGUAGE plpgsql
AS $function$
BEGIN
DELETE FROM catalog.equipment_type WHERE id = "Key";
END;
$function$
*/
}
/**
* @function catalog_equipment_type_r
* @memberof zzglc
* @description Catalog equipment type r
* @returns {Object} integer idcharacter_varying nameinteger catalog_application__application_idinteger catalog_observation_type__observation_type_idcharacter_varying catalog_application__application_id_valcharacter_varying catalog_observation_type__observation_type_id_val
*/
function catalog_equipment_type_r() {
/*
CREATE OR REPLACE FUNCTION zzglc.catalog_equipment_type_r()
RETURNS TABLE(id integer, name character varying, catalog_application__application_id integer, catalog_observation_type__observation_type_id integer, catalog_application__application_id_val character varying, catalog_observation_type__observation_type_id_val character varying)
LANGUAGE plpgsql
AS $function$
BEGIN
RETURN QUERY (
SELECT t.id, t.name, t.application_id, t.observation_type_id, application_id.name, observation_type_id.name
FROM catalog.equipment_type t
LEFT JOIN catalog.application application_id ON application_id.id = t.application_id
LEFT JOIN catalog.observation_type observation_type_id ON observation_type_id.id = t.observation_type_id
ORDER BY 2
);
END $function$
*/
}
/**
* @function catalog_equipment_type_u
* @memberof zzglc
* @description Catalog equipment type u
* @param {character_varying} Json
* @returns {integer}
*/
function catalog_equipment_type_u() {
/*
CREATE OR REPLACE FUNCTION zzglc.catalog_equipment_type_u("Json" character varying)
RETURNS integer
LANGUAGE plpgsql
AS $function$
DECLARE v_id integer;
DECLARE json_data json;
BEGIN
json_data := "Json";
v_id := (json_data->>'id')::integer;
UPDATE catalog.equipment_type SET
name = (json_data->>'name')::character varying,
application_id = (json_data->>'application_id')::integer,
observation_type_id = (json_data->>'observation_type_id')::integer
WHERE id = v_id;
RETURN v_id;
END $function$
*/
}
/**
* @function catalog_erosion_conservation_measure_c
* @memberof zzglc
* @description Catalog erosion conservation measure c
* @param {character_varying} Json
* @returns {integer}
*/
function catalog_erosion_conservation_measure_c() {
/*
CREATE OR REPLACE FUNCTION zzglc.catalog_erosion_conservation_measure_c("Json" character varying)
RETURNS integer
LANGUAGE plpgsql
AS $function$
DECLARE v_id integer;
DECLARE json_data json;
BEGIN
json_data := "Json";
INSERT INTO catalog.erosion_conservation_measure (name)
VALUES ((json_data->>'name')::character varying)
RETURNING id INTO v_id;
RETURN v_id;
END $function$
*/
}
/**
* @function catalog_erosion_conservation_measure_d
* @memberof zzglc
* @description Catalog erosion conservation measure d
* @param {integer} Key
* @returns {void}
*/
function catalog_erosion_conservation_measure_d() {
/*
CREATE OR REPLACE FUNCTION zzglc.catalog_erosion_conservation_measure_d("Key" integer)
RETURNS void
LANGUAGE plpgsql
AS $function$
BEGIN
DELETE FROM catalog.erosion_conservation_measure WHERE id = "Key";
END;
$function$
*/
}
/**
* @function catalog_erosion_conservation_measure_r
* @memberof zzglc
* @description Catalog erosion conservation measure r
* @returns {Object} integer idcharacter_varying name
*/
function catalog_erosion_conservation_measure_r() {
/*
CREATE OR REPLACE FUNCTION zzglc.catalog_erosion_conservation_measure_r()
RETURNS TABLE(id integer, name character varying)
LANGUAGE plpgsql
AS $function$
BEGIN
RETURN QUERY (
SELECT t.id, t.name
FROM catalog.erosion_conservation_measure t
ORDER BY 2
);
END $function$
*/
}
/**
* @function catalog_erosion_conservation_measure_u
* @memberof zzglc
* @description Catalog erosion conservation measure u
* @param {character_varying} Json
* @returns {integer}
*/
function catalog_erosion_conservation_measure_u() {
/*
CREATE OR REPLACE FUNCTION zzglc.catalog_erosion_conservation_measure_u("Json" character varying)
RETURNS integer
LANGUAGE plpgsql
AS $function$
DECLARE v_id integer;
DECLARE json_data json;
BEGIN
json_data := "Json";
v_id := (json_data->>'id')::integer;
UPDATE catalog.erosion_conservation_measure SET
name = (json_data->>'name')::character varying
WHERE id = v_id;
RETURN v_id;
END $function$
*/
}
/**
* @function catalog_extraction_c
* @memberof zzglc
* @description Catalog extraction c
* @param {character_varying} Json
* @returns {integer}
*/
function catalog_extraction_c() {
/*
CREATE OR REPLACE FUNCTION zzglc.catalog_extraction_c("Json" character varying)
RETURNS integer
LANGUAGE plpgsql
AS $function$
DECLARE v_id integer;
DECLARE json_data json;
BEGIN
json_data := "Json";
INSERT INTO catalog.extraction (name)
VALUES ((json_data->>'name')::character varying)
RETURNING id INTO v_id;
RETURN v_id;
END $function$
*/
}
/**
* @function catalog_extraction_d
* @memberof zzglc
* @description Catalog extraction d
* @param {integer} Key
* @returns {void}
*/
function catalog_extraction_d() {
/*
CREATE OR REPLACE FUNCTION zzglc.catalog_extraction_d("Key" integer)
RETURNS void
LANGUAGE plpgsql
AS $function$
BEGIN
DELETE FROM catalog.extraction WHERE id = "Key";
END;
$function$
*/
}
/**
* @function catalog_extraction_method_c
* @memberof zzglc
* @description Catalog extraction method c
* @param {character_varying} Json
* @returns {integer}
*/
function catalog_extraction_method_c() {
/*
CREATE OR REPLACE FUNCTION zzglc.catalog_extraction_method_c("Json" character varying)
RETURNS integer
LANGUAGE plpgsql
AS $function$
DECLARE v_id integer;
DECLARE json_data json;
BEGIN
json_data := "Json";
INSERT INTO catalog.extraction_method (name)
VALUES ((json_data->>'name')::character varying)
RETURNING id INTO v_id;
RETURN v_id;
END $function$
*/
}
/**
* @function catalog_extraction_method_d
* @memberof zzglc
* @description Catalog extraction method d
* @param {integer} Key
* @returns {void}
*/
function catalog_extraction_method_d() {
/*
CREATE OR REPLACE FUNCTION zzglc.catalog_extraction_method_d("Key" integer)
RETURNS void
LANGUAGE plpgsql
AS $function$
BEGIN
DELETE FROM catalog.extraction_method WHERE id = "Key";
END;
$function$
*/
}
/**
* @function catalog_extraction_method_r
* @memberof zzglc
* @description Catalog extraction method r
* @returns {Object} integer idcharacter_varying name
*/
function catalog_extraction_method_r() {
/*
CREATE OR REPLACE FUNCTION zzglc.catalog_extraction_method_r()
RETURNS TABLE(id integer, name character varying)
LANGUAGE plpgsql
AS $function$
BEGIN
RETURN QUERY (
SELECT t.id, t.name
FROM catalog.extraction_method t
ORDER BY 2
);
END $function$
*/
}
/**
* @function catalog_extraction_method_u
* @memberof zzglc
* @description Catalog extraction method u
* @param {character_varying} Json
* @returns {integer}
*/
function catalog_extraction_method_u() {
/*
CREATE OR REPLACE FUNCTION zzglc.catalog_extraction_method_u("Json" character varying)
RETURNS integer
LANGUAGE plpgsql
AS $function$
DECLARE v_id integer;
DECLARE json_data json;
BEGIN
json_data := "Json";
v_id := (json_data->>'id')::integer;
UPDATE catalog.extraction_method SET
name = (json_data->>'name')::character varying
WHERE id = v_id;
RETURN v_id;
END $function$
*/
}
/**
* @function catalog_extraction_r
* @memberof zzglc
* @description Catalog extraction r
* @returns {Object} integer idcharacter_varying name
*/
function catalog_extraction_r() {
/*
CREATE OR REPLACE FUNCTION zzglc.catalog_extraction_r()
RETURNS TABLE(id integer, name character varying)
LANGUAGE plpgsql
AS $function$
BEGIN
RETURN QUERY (
SELECT t.id, t.name
FROM catalog.extraction t
ORDER BY 2
);
END $function$
*/
}
/**
* @function catalog_extraction_u
* @memberof zzglc
* @description Catalog extraction u
* @param {character_varying} Json
* @returns {integer}
*/
function catalog_extraction_u() {
/*
CREATE OR REPLACE FUNCTION zzglc.catalog_extraction_u("Json" character varying)
RETURNS integer
LANGUAGE plpgsql
AS $function$
DECLARE v_id integer;
DECLARE json_data json;
BEGIN
json_data := "Json";
v_id := (json_data->>'id')::integer;
UPDATE catalog.extraction SET
name = (json_data->>'name')::character varying
WHERE id = v_id;
RETURN v_id;
END $function$
*/
}
/**
* @function catalog_fao_standard_c
* @memberof zzglc
* @description Catalog fao standard c
* @param {character_varying} Json
* @returns {integer}
*/
function catalog_fao_standard_c() {
/*
CREATE OR REPLACE FUNCTION zzglc.catalog_fao_standard_c("Json" character varying)
RETURNS integer
LANGUAGE plpgsql
AS $function$
DECLARE v_id integer;
DECLARE json_data json;
BEGIN
json_data := "Json";
INSERT INTO catalog.fao_standard (name, identifyer, version, effective_from)
VALUES ((json_data->>'name')::character varying, (json_data->>'identifyer')::character varying, (json_data->>'version')::character varying, (json_data->>'effective_from')::date)
RETURNING id INTO v_id;
RETURN v_id;
END $function$
*/
}
/**
* @function catalog_fao_standard_d
* @memberof zzglc
* @description Catalog fao standard d
* @param {integer} Key
* @returns {void}
*/
function catalog_fao_standard_d() {
/*
CREATE OR REPLACE FUNCTION zzglc.catalog_fao_standard_d("Key" integer)
RETURNS void
LANGUAGE plpgsql
AS $function$
BEGIN
DELETE FROM catalog.fao_standard WHERE id = "Key";
END;
$function$
*/
}
/**
* @function catalog_fao_standard_r
* @memberof zzglc
* @description Catalog fao standard r
* @returns {Object} integer idcharacter_varying namecharacter_varying identifyercharacter_varying versiondate effective_from
*/
function catalog_fao_standard_r() {
/*
CREATE OR REPLACE FUNCTION zzglc.catalog_fao_standard_r()
RETURNS TABLE(id integer, name character varying, identifyer character varying, version character varying, effective_from date)
LANGUAGE plpgsql
AS $function$
BEGIN
RETURN QUERY (
SELECT t.id, t.name, t.identifyer, t.version, t.effective_from
FROM catalog.fao_standard t
ORDER BY 2
);
END $function$
*/
}
/**
* @function catalog_fao_standard_u
* @memberof zzglc
* @description Catalog fao standard u
* @param {character_varying} Json
* @returns {void}
*/
function catalog_fao_standard_u() {
/*
CREATE OR REPLACE FUNCTION zzglc.catalog_fao_standard_u("Json" character varying)
RETURNS void
LANGUAGE plpgsql
AS $function$
DECLARE json_data json;
BEGIN
json_data := "Json";
UPDATE catalog.fao_standard SET
name = (json_data->>'name')::character varying,
identifyer = (json_data->>'identifyer')::character varying,
version = (json_data->>'version')::character varying,
effective_from = (json_data->>'effective_from')::date
WHERE id = (json_data->>'id')::integer;
END $function$
*/
}
/**
* @function catalog_ground_condition_c
* @memberof zzglc
* @description Catalog ground condition c
* @param {character_varying} Json
* @returns {integer}
*/
function catalog_ground_condition_c() {
/*
CREATE OR REPLACE FUNCTION zzglc.catalog_ground_condition_c("Json" character varying)
RETURNS integer
LANGUAGE plpgsql
AS $function$
DECLARE v_id integer;
DECLARE json_data json;
BEGIN
json_data := "Json";
INSERT INTO catalog.ground_condition (name)
VALUES ((json_data->>'name')::character varying)
RETURNING id INTO v_id;
RETURN v_id;
END $function$
*/
}
/**
* @function catalog_ground_condition_d
* @memberof zzglc
* @description Catalog ground condition d
* @param {integer} Key
* @returns {void}
*/
function catalog_ground_condition_d() {
/*
CREATE OR REPLACE FUNCTION zzglc.catalog_ground_condition_d("Key" integer)
RETURNS void
LANGUAGE plpgsql
AS $function$
BEGIN
DELETE FROM catalog.ground_condition WHERE id = "Key";
END;
$function$
*/
}
/**
* @function catalog_ground_condition_r
* @memberof zzglc
* @description Catalog ground condition r
* @returns {Object} integer idcharacter_varying name
*/
function catalog_ground_condition_r() {
/*
CREATE OR REPLACE FUNCTION zzglc.catalog_ground_condition_r()
RETURNS TABLE(id integer, name character varying)
LANGUAGE plpgsql
AS $function$
BEGIN
RETURN QUERY (
SELECT t.id, t.name
FROM catalog.ground_condition t
ORDER BY 2
);
END $function$
*/
}
/**
* @function catalog_ground_condition_u
* @memberof zzglc
* @description Catalog ground condition u
* @param {character_varying} Json
* @returns {integer}
*/
function catalog_ground_condition_u() {
/*
CREATE OR REPLACE FUNCTION zzglc.catalog_ground_condition_u("Json" character varying)
RETURNS integer
LANGUAGE plpgsql
AS $function$
DECLARE v_id integer;
DECLARE json_data json;
BEGIN
json_data := "Json";
v_id := (json_data->>'id')::integer;
UPDATE catalog.ground_condition SET
name = (json_data->>'name')::character varying
WHERE id = v_id;
RETURN v_id;
END $function$
*/
}
/**
* @function catalog_hillslope_position_c
* @memberof zzglc
* @description Catalog hillslope position c
* @param {character_varying} Json
* @returns {integer}
*/
function catalog_hillslope_position_c() {
/*
CREATE OR REPLACE FUNCTION zzglc.catalog_hillslope_position_c("Json" character varying)
RETURNS integer
LANGUAGE plpgsql
AS $function$
DECLARE v_id integer;
DECLARE json_data json;
BEGIN
json_data := "Json";
INSERT INTO catalog.hillslope_position (name)
VALUES ((json_data->>'name')::character varying)
RETURNING id INTO v_id;
RETURN v_id;
END $function$
*/
}
/**
* @function catalog_hillslope_position_d
* @memberof zzglc
* @description Catalog hillslope position d
* @param {integer} Key
* @returns {void}
*/
function catalog_hillslope_position_d() {
/*
CREATE OR REPLACE FUNCTION zzglc.catalog_hillslope_position_d("Key" integer)
RETURNS void
LANGUAGE plpgsql
AS $function$
BEGIN
DELETE FROM catalog.hillslope_position WHERE id = "Key";
END;
$function$
*/
}
/**
* @function catalog_hillslope_position_r
* @memberof zzglc
* @description Catalog hillslope position r
* @returns {Object} integer idcharacter_varying name
*/
function catalog_hillslope_position_r() {
/*
CREATE OR REPLACE FUNCTION zzglc.catalog_hillslope_position_r()
RETURNS TABLE(id integer, name character varying)
LANGUAGE plpgsql
AS $function$
BEGIN
RETURN QUERY (
SELECT t.id, t.name
FROM catalog.hillslope_position t
ORDER BY 2
);
END $function$
*/
}
/**
* @function catalog_hillslope_position_u
* @memberof zzglc
* @description Catalog hillslope position u
* @param {character_varying} Json
* @returns {integer}
*/
function catalog_hillslope_position_u() {
/*
CREATE OR REPLACE FUNCTION zzglc.catalog_hillslope_position_u("Json" character varying)
RETURNS integer
LANGUAGE plpgsql
AS $function$
DECLARE v_id integer;
DECLARE json_data json;
BEGIN
json_data := "Json";
v_id := (json_data->>'id')::integer;
UPDATE catalog.hillslope_position SET
name = (json_data->>'name')::character varying
WHERE id = v_id;
RETURN v_id;
END $function$
*/
}
/**
* @function catalog_image_approach_c
* @memberof zzglc
* @description Catalog image approach c
* @param {character_varying} Json
* @returns {integer}
*/
function catalog_image_approach_c() {
/*
CREATE OR REPLACE FUNCTION zzglc.catalog_image_approach_c("Json" character varying)
RETURNS integer
LANGUAGE plpgsql
AS $function$
DECLARE v_id integer;
DECLARE json_data json;
BEGIN
json_data := "Json";
INSERT INTO catalog.image_approach (name)
VALUES ((json_data->>'name')::character varying)
RETURNING id INTO v_id;
RETURN v_id;
END $function$
*/
}
/**
* @function catalog_image_approach_d
* @memberof zzglc
* @description Catalog image approach d
* @param {integer} Key
* @returns {void}
*/
function catalog_image_approach_d() {
/*
CREATE OR REPLACE FUNCTION zzglc.catalog_image_approach_d("Key" integer)
RETURNS void
LANGUAGE plpgsql
AS $function$
BEGIN
DELETE FROM catalog.image_approach WHERE id = "Key";
END;
$function$
*/
}
/**
* @function catalog_image_approach_r
* @memberof zzglc
* @description Catalog image approach r
* @returns {Object} integer idcharacter_varying name
*/
function catalog_image_approach_r() {
/*
CREATE OR REPLACE FUNCTION zzglc.catalog_image_approach_r()
RETURNS TABLE(id integer, name character varying)
LANGUAGE plpgsql
AS $function$
BEGIN
RETURN QUERY (
SELECT t.id, t.name
FROM catalog.image_approach t
ORDER BY 2
);
END $function$
*/
}
/**
* @function catalog_image_approach_u
* @memberof zzglc
* @description Catalog image approach u
* @param {character_varying} Json
* @returns {integer}
*/
function catalog_image_approach_u() {
/*
CREATE OR REPLACE FUNCTION zzglc.catalog_image_approach_u("Json" character varying)
RETURNS integer
LANGUAGE plpgsql
AS $function$
DECLARE v_id integer;
DECLARE json_data json;
BEGIN
json_data := "Json";
v_id := (json_data->>'id')::integer;
UPDATE catalog.image_approach SET
name = (json_data->>'name')::character varying
WHERE id = v_id;
RETURN v_id;
END $function$
*/
}
/**
* @function catalog_image_camera_c
* @memberof zzglc
* @description Catalog image camera c
* @param {character_varying} Json
* @returns {integer}
*/
function catalog_image_camera_c() {
/*
CREATE OR REPLACE FUNCTION zzglc.catalog_image_camera_c("Json" character varying)
RETURNS integer
LANGUAGE plpgsql
AS $function$
DECLARE v_id integer;
DECLARE json_data json;
BEGIN
json_data := "Json";
INSERT INTO catalog.image_camera (name)
VALUES ((json_data->>'name')::character varying)
RETURNING id INTO v_id;
RETURN v_id;
END $function$
*/
}
/**
* @function catalog_image_camera_d
* @memberof zzglc
* @description Catalog image camera d
* @param {integer} Key
* @returns {void}
*/
function catalog_image_camera_d() {
/*
CREATE OR REPLACE FUNCTION zzglc.catalog_image_camera_d("Key" integer)
RETURNS void
LANGUAGE plpgsql
AS $function$
BEGIN
DELETE FROM catalog.image_camera WHERE id = "Key";
END;
$function$
*/
}
/**
* @function catalog_image_camera_r
* @memberof zzglc
* @description Catalog image camera r
* @returns {Object} integer idcharacter_varying name
*/
function catalog_image_camera_r() {
/*
CREATE OR REPLACE FUNCTION zzglc.catalog_image_camera_r()
RETURNS TABLE(id integer, name character varying)
LANGUAGE plpgsql
AS $function$
BEGIN
RETURN QUERY (
SELECT t.id, t.name
FROM catalog.image_camera t
ORDER BY 2
);
END $function$
*/
}
/**
* @function catalog_image_camera_u
* @memberof zzglc
* @description Catalog image camera u
* @param {character_varying} Json
* @returns {integer}
*/
function catalog_image_camera_u() {
/*
CREATE OR REPLACE FUNCTION zzglc.catalog_image_camera_u("Json" character varying)
RETURNS integer
LANGUAGE plpgsql
AS $function$
DECLARE v_id integer;
DECLARE json_data json;
BEGIN
json_data := "Json";
v_id := (json_data->>'id')::integer;
UPDATE catalog.image_camera SET
name = (json_data->>'name')::character varying
WHERE id = v_id;
RETURN v_id;
END $function$
*/
}
/**
* @function catalog_image_lightsource_c
* @memberof zzglc
* @description Catalog image lightsource c
* @param {character_varying} Json
* @returns {integer}
*/
function catalog_image_lightsource_c() {
/*
CREATE OR REPLACE FUNCTION zzglc.catalog_image_lightsource_c("Json" character varying)
RETURNS integer
LANGUAGE plpgsql
AS $function$
DECLARE v_id integer;
DECLARE json_data json;
BEGIN
json_data := "Json";
INSERT INTO catalog.image_lightsource (name)
VALUES ((json_data->>'name')::character varying)
RETURNING id INTO v_id;
RETURN v_id;
END $function$
*/
}
/**
* @function catalog_image_lightsource_d
* @memberof zzglc
* @description Catalog image lightsource d
* @param {integer} Key
* @returns {void}
*/
function catalog_image_lightsource_d() {
/*
CREATE OR REPLACE FUNCTION zzglc.catalog_image_lightsource_d("Key" integer)
RETURNS void
LANGUAGE plpgsql
AS $function$
BEGIN
DELETE FROM catalog.image_lightsource WHERE id = "Key";
END;
$function$
*/
}
/**
* @function catalog_image_lightsource_r
* @memberof zzglc
* @description Catalog image lightsource r
* @returns {Object} integer idcharacter_varying name
*/
function catalog_image_lightsource_r() {
/*
CREATE OR REPLACE FUNCTION zzglc.catalog_image_lightsource_r()
RETURNS TABLE(id integer, name character varying)
LANGUAGE plpgsql
AS $function$
BEGIN
RETURN QUERY (
SELECT t.id, t.name
FROM catalog.image_lightsource t
ORDER BY 2
);
END $function$
*/
}
/**
* @function catalog_image_lightsource_u
* @memberof zzglc
* @description Catalog image lightsource u
* @param {character_varying} Json
* @returns {integer}
*/
function catalog_image_lightsource_u() {
/*
CREATE OR REPLACE FUNCTION zzglc.catalog_image_lightsource_u("Json" character varying)
RETURNS integer
LANGUAGE plpgsql
AS $function$
DECLARE v_id integer;
DECLARE json_data json;
BEGIN
json_data := "Json";
v_id := (json_data->>'id')::integer;
UPDATE catalog.image_lightsource SET
name = (json_data->>'name')::character varying
WHERE id = v_id;
RETURN v_id;
END $function$
*/
}
/**
* @function catalog_image_setup_c
* @memberof zzglc
* @description Catalog image setup c
* @param {character_varying} Json
* @returns {integer}
*/
function catalog_image_setup_c() {
/*
CREATE OR REPLACE FUNCTION zzglc.catalog_image_setup_c("Json" character varying)
RETURNS integer
LANGUAGE plpgsql
AS $function$
DECLARE v_id integer;
DECLARE json_data json;
BEGIN
json_data := "Json";
INSERT INTO catalog.image_setup (name)
VALUES ((json_data->>'name')::character varying)
RETURNING id INTO v_id;
RETURN v_id;
END $function$
*/
}
/**
* @function catalog_image_setup_d
* @memberof zzglc
* @description Catalog image setup d
* @param {integer} Key
* @returns {void}
*/
function catalog_image_setup_d() {
/*
CREATE OR REPLACE FUNCTION zzglc.catalog_image_setup_d("Key" integer)
RETURNS void
LANGUAGE plpgsql
AS $function$
BEGIN
DELETE FROM catalog.image_setup WHERE id = "Key";
END;
$function$
*/
}
/**
* @function catalog_image_setup_r
* @memberof zzglc
* @description Catalog image setup r
* @returns {Object} integer idcharacter_varying name
*/
function catalog_image_setup_r() {
/*
CREATE OR REPLACE FUNCTION zzglc.catalog_image_setup_r()
RETURNS TABLE(id integer, name character varying)
LANGUAGE plpgsql
AS $function$
BEGIN
RETURN QUERY (
SELECT t.id, t.name
FROM catalog.image_setup t
ORDER BY 2
);
END $function$
*/
}
/**
* @function catalog_image_setup_u
* @memberof zzglc
* @description Catalog image setup u
* @param {character_varying} Json
* @returns {integer}
*/
function catalog_image_setup_u() {
/*
CREATE OR REPLACE FUNCTION zzglc.catalog_image_setup_u("Json" character varying)
RETURNS integer
LANGUAGE plpgsql
AS $function$
DECLARE v_id integer;
DECLARE json_data json;
BEGIN
json_data := "Json";
v_id := (json_data->>'id')::integer;
UPDATE catalog.image_setup SET
name = (json_data->>'name')::character varying
WHERE id = v_id;
RETURN v_id;
END $function$
*/
}
/**
* @function catalog_image_substrate_c
* @memberof zzglc
* @description Catalog image substrate c
* @param {character_varying} Json
* @returns {integer}
*/
function catalog_image_substrate_c() {
/*
CREATE OR REPLACE FUNCTION zzglc.catalog_image_substrate_c("Json" character varying)
RETURNS integer
LANGUAGE plpgsql
AS $function$
DECLARE v_id integer;
DECLARE json_data json;
BEGIN
json_data := "Json";
INSERT INTO catalog.image_substrate (name)
VALUES ((json_data->>'name')::character varying)
RETURNING id INTO v_id;
RETURN v_id;
END $function$
*/
}
/**
* @function catalog_image_substrate_d
* @memberof zzglc
* @description Catalog image substrate d
* @param {integer} Key
* @returns {void}
*/
function catalog_image_substrate_d() {
/*
CREATE OR REPLACE FUNCTION zzglc.catalog_image_substrate_d("Key" integer)
RETURNS void
LANGUAGE plpgsql
AS $function$
BEGIN
DELETE FROM catalog.image_substrate WHERE id = "Key";
END;
$function$
*/
}
/**
* @function catalog_image_substrate_r
* @memberof zzglc
* @description Catalog image substrate r
* @returns {Object} integer idcharacter_varying name
*/
function catalog_image_substrate_r() {
/*
CREATE OR REPLACE FUNCTION zzglc.catalog_image_substrate_r()
RETURNS TABLE(id integer, name character varying)
LANGUAGE plpgsql
AS $function$
BEGIN
RETURN QUERY (
SELECT t.id, t.name
FROM catalog.image_substrate t
ORDER BY 2
);
END $function$
*/
}
/**
* @function catalog_image_substrate_u
* @memberof zzglc
* @description Catalog image substrate u
* @param {character_varying} Json
* @returns {integer}
*/
function catalog_image_substrate_u() {
/*
CREATE OR REPLACE FUNCTION zzglc.catalog_image_substrate_u("Json" character varying)
RETURNS integer
LANGUAGE plpgsql
AS $function$
DECLARE v_id integer;
DECLARE json_data json;
BEGIN
json_data := "Json";
v_id := (json_data->>'id')::integer;
UPDATE catalog.image_substrate SET
name = (json_data->>'name')::character varying
WHERE id = v_id;
RETURN v_id;
END $function$
*/
}
/**
* @function catalog_layer_c
* @memberof zzglc
* @description Catalog layer c
* @param {character_varying} Json
* @returns {integer}
*/
function catalog_layer_c() {
/*
CREATE OR REPLACE FUNCTION zzglc.catalog_layer_c("Json" character varying)
RETURNS integer
LANGUAGE plpgsql
AS $function$
DECLARE v_id integer;
DECLARE json_data json;
BEGIN
json_data := "Json";
INSERT INTO catalog.layer (name)
VALUES ((json_data->>'name')::character varying)
RETURNING id INTO v_id;
RETURN v_id;
END $function$
*/
}
/**
* @function catalog_layer_d
* @memberof zzglc
* @description Catalog layer d
* @param {integer} Key
* @returns {void}
*/
function catalog_layer_d() {
/*
CREATE OR REPLACE FUNCTION zzglc.catalog_layer_d("Key" integer)
RETURNS void
LANGUAGE plpgsql
AS $function$
BEGIN
DELETE FROM catalog.layer WHERE id = "Key";
END;
$function$
*/
}
/**
* @function catalog_layer_r
* @memberof zzglc
* @description Catalog layer r
* @returns {Object} integer idcharacter_varying name
*/
function catalog_layer_r() {
/*
CREATE OR REPLACE FUNCTION zzglc.catalog_layer_r()
RETURNS TABLE(id integer, name character varying)
LANGUAGE plpgsql
AS $function$
BEGIN
RETURN QUERY (
SELECT t.id, t.name
FROM catalog.layer t
ORDER BY 2
);
END $function$
*/
}
/**
* @function catalog_layer_u
* @memberof zzglc
* @description Catalog layer u
* @param {character_varying} Json
* @returns {integer}
*/
function catalog_layer_u() {
/*
CREATE OR REPLACE FUNCTION zzglc.catalog_layer_u("Json" character varying)
RETURNS integer
LANGUAGE plpgsql
AS $function$
DECLARE v_id integer;
DECLARE json_data json;
BEGIN
json_data := "Json";
v_id := (json_data->>'id')::integer;
UPDATE catalog.layer SET
name = (json_data->>'name')::character varying
WHERE id = v_id;
RETURN v_id;
END $function$
*/
}
/**
* @function catalog_license_c
* @memberof zzglc
* @description Catalog license c
* @param {character_varying} Json
* @returns {integer}
*/
function catalog_license_c() {
/*
CREATE OR REPLACE FUNCTION zzglc.catalog_license_c("Json" character varying)
RETURNS integer
LANGUAGE plpgsql
AS $function$
DECLARE v_id integer;
DECLARE json_data json;
BEGIN
json_data := "Json";
INSERT INTO catalog.license (name)
VALUES ((json_data->>'name')::character varying)
RETURNING id INTO v_id;
RETURN v_id;
END $function$
*/
}
/**
* @function catalog_license_d
* @memberof zzglc
* @description Catalog license d
* @param {integer} Key
* @returns {void}
*/
function catalog_license_d() {
/*
CREATE OR REPLACE FUNCTION zzglc.catalog_license_d("Key" integer)
RETURNS void
LANGUAGE plpgsql
AS $function$
BEGIN
DELETE FROM catalog.license WHERE id = "Key";
END;
$function$
*/
}
/**
* @function catalog_license_r
* @memberof zzglc
* @description Catalog license r
* @returns {Object} integer idcharacter_varying name
*/
function catalog_license_r() {
/*
CREATE OR REPLACE FUNCTION zzglc.catalog_license_r()
RETURNS TABLE(id integer, name character varying)
LANGUAGE plpgsql
AS $function$
BEGIN
RETURN QUERY (
SELECT t.id, t.name
FROM catalog.license t
ORDER BY 2
);
END $function$
*/
}
/**
* @function catalog_license_u
* @memberof zzglc
* @description Catalog license u
* @param {character_varying} Json
* @returns {integer}
*/
function catalog_license_u() {
/*
CREATE OR REPLACE FUNCTION zzglc.catalog_license_u("Json" character varying)
RETURNS integer
LANGUAGE plpgsql
AS $function$
DECLARE v_id integer;
DECLARE json_data json;
BEGIN
json_data := "Json";
v_id := (json_data->>'id')::integer;
UPDATE catalog.license SET
name = (json_data->>'name')::character varying
WHERE id = v_id;
RETURN v_id;
END $function$
*/
}
/**
* @function catalog_life_cycle_stage_c
* @memberof zzglc
* @description Catalog life cycle stage c
* @param {character_varying} Json
* @returns {integer}
*/
function catalog_life_cycle_stage_c() {
/*
CREATE OR REPLACE FUNCTION zzglc.catalog_life_cycle_stage_c("Json" character varying)
RETURNS integer
LANGUAGE plpgsql
AS $function$
DECLARE v_id integer;
DECLARE json_data json;
BEGIN
json_data := "Json";
INSERT INTO catalog.life_cycle_stage (name)
VALUES ((json_data->>'name')::character varying)
RETURNING id INTO v_id;
RETURN v_id;
END $function$
*/
}
/**
* @function catalog_life_cycle_stage_d
* @memberof zzglc
* @description Catalog life cycle stage d
* @param {integer} Key
* @returns {void}
*/
function catalog_life_cycle_stage_d() {
/*
CREATE OR REPLACE FUNCTION zzglc.catalog_life_cycle_stage_d("Key" integer)
RETURNS void
LANGUAGE plpgsql
AS $function$
BEGIN
DELETE FROM catalog.life_cycle_stage WHERE id = "Key";
END;
$function$
*/
}
/**
* @function catalog_life_cycle_stage_r
* @memberof zzglc
* @description Catalog life cycle stage r
* @returns {Object} integer idcharacter_varying name
*/
function catalog_life_cycle_stage_r() {
/*
CREATE OR REPLACE FUNCTION zzglc.catalog_life_cycle_stage_r()
RETURNS TABLE(id integer, name character varying)
LANGUAGE plpgsql
AS $function$
BEGIN
RETURN QUERY (
SELECT t.id, t.name
FROM catalog.life_cycle_stage t
ORDER BY 2
);
END $function$
*/
}
/**
* @function catalog_life_cycle_stage_u
* @memberof zzglc
* @description Catalog life cycle stage u
* @param {character_varying} Json
* @returns {integer}
*/
function catalog_life_cycle_stage_u() {
/*
CREATE OR REPLACE FUNCTION zzglc.catalog_life_cycle_stage_u("Json" character varying)
RETURNS integer
LANGUAGE plpgsql
AS $function$
DECLARE v_id integer;
DECLARE json_data json;
BEGIN
json_data := "Json";
v_id := (json_data->>'id')::integer;
UPDATE catalog.life_cycle_stage SET
name = (json_data->>'name')::character varying
WHERE id = v_id;
RETURN v_id;
END $function$
*/
}
/**
* @function catalog_macrofauna_excavation_tool_c
* @memberof zzglc
* @description Catalog macrofauna excavation tool c
* @param {character_varying} Json
* @returns {integer}
*/
function catalog_macrofauna_excavation_tool_c() {
/*
CREATE OR REPLACE FUNCTION zzglc.catalog_macrofauna_excavation_tool_c("Json" character varying)
RETURNS integer
LANGUAGE plpgsql
AS $function$
DECLARE v_id integer;
DECLARE json_data json;
BEGIN
json_data := "Json";
INSERT INTO catalog.macrofauna_excavation_tool (name)
VALUES ((json_data->>'name')::character varying)
RETURNING id INTO v_id;
RETURN v_id;
END $function$
*/
}
/**
* @function catalog_macrofauna_excavation_tool_d
* @memberof zzglc
* @description Catalog macrofauna excavation tool d
* @param {integer} Key
* @returns {void}
*/
function catalog_macrofauna_excavation_tool_d() {
/*
CREATE OR REPLACE FUNCTION zzglc.catalog_macrofauna_excavation_tool_d("Key" integer)
RETURNS void
LANGUAGE plpgsql
AS $function$
BEGIN
DELETE FROM catalog.macrofauna_excavation_tool WHERE id = "Key";
END;
$function$
*/
}
/**
* @function catalog_macrofauna_excavation_tool_r
* @memberof zzglc
* @description Catalog macrofauna excavation tool r
* @returns {Object} integer idcharacter_varying name
*/
function catalog_macrofauna_excavation_tool_r() {
/*
CREATE OR REPLACE FUNCTION zzglc.catalog_macrofauna_excavation_tool_r()
RETURNS TABLE(id integer, name character varying)
LANGUAGE plpgsql
AS $function$
BEGIN
RETURN QUERY (
SELECT t.id, t.name
FROM catalog.macrofauna_excavation_tool t
ORDER BY 2
);
END $function$
*/
}
/**
* @function catalog_macrofauna_excavation_tool_u
* @memberof zzglc
* @description Catalog macrofauna excavation tool u
* @param {character_varying} Json
* @returns {integer}
*/
function catalog_macrofauna_excavation_tool_u() {
/*
CREATE OR REPLACE FUNCTION zzglc.catalog_macrofauna_excavation_tool_u("Json" character varying)
RETURNS integer
LANGUAGE plpgsql
AS $function$
DECLARE v_id integer;
DECLARE json_data json;
BEGIN
json_data := "Json";
v_id := (json_data->>'id')::integer;
UPDATE catalog.macrofauna_excavation_tool SET
name = (json_data->>'name')::character varying
WHERE id = v_id;
RETURN v_id;
END $function$
*/
}
/**
* @function catalog_major_landform_c
* @memberof zzglc
* @description Catalog major landform c
* @param {character_varying} Json
* @returns {integer}
*/
function catalog_major_landform_c() {
/*
CREATE OR REPLACE FUNCTION zzglc.catalog_major_landform_c("Json" character varying)
RETURNS integer
LANGUAGE plpgsql
AS $function$
DECLARE v_id integer;
DECLARE json_data json;
BEGIN
json_data := "Json";
INSERT INTO catalog.major_landform (name)
VALUES ((json_data->>'name')::character varying)
RETURNING id INTO v_id;
RETURN v_id;
END $function$
*/
}
/**
* @function catalog_major_landform_d
* @memberof zzglc
* @description Catalog major landform d
* @param {integer} Key
* @returns {void}
*/
function catalog_major_landform_d() {
/*
CREATE OR REPLACE FUNCTION zzglc.catalog_major_landform_d("Key" integer)
RETURNS void
LANGUAGE plpgsql
AS $function$
BEGIN
DELETE FROM catalog.major_landform WHERE id = "Key";
END;
$function$
*/
}
/**
* @function catalog_major_landform_r
* @memberof zzglc
* @description Catalog major landform r
* @returns {Object} integer idcharacter_varying name
*/
function catalog_major_landform_r() {
/*
CREATE OR REPLACE FUNCTION zzglc.catalog_major_landform_r()
RETURNS TABLE(id integer, name character varying)
LANGUAGE plpgsql
AS $function$
BEGIN
RETURN QUERY (
SELECT t.id, t.name
FROM catalog.major_landform t
ORDER BY 2
);
END $function$
*/
}
/**
* @function catalog_major_landform_u
* @memberof zzglc
* @description Catalog major landform u
* @param {character_varying} Json
* @returns {integer}
*/
function catalog_major_landform_u() {
/*
CREATE OR REPLACE FUNCTION zzglc.catalog_major_landform_u("Json" character varying)
RETURNS integer
LANGUAGE plpgsql
AS $function$
DECLARE v_id integer;
DECLARE json_data json;
BEGIN
json_data := "Json";
v_id := (json_data->>'id')::integer;
UPDATE catalog.major_landform SET
name = (json_data->>'name')::character varying
WHERE id = v_id;
RETURN v_id;
END $function$
*/
}
/**
* @function catalog_monolith_c
* @memberof zzglc
* @description Catalog monolith c
* @param {character_varying} Json
* @returns {integer}
*/
function catalog_monolith_c() {
/*
CREATE OR REPLACE FUNCTION zzglc.catalog_monolith_c("Json" character varying)
RETURNS integer
LANGUAGE plpgsql
AS $function$
DECLARE v_id integer;
DECLARE json_data json;
BEGIN
json_data := "Json";
INSERT INTO catalog.monolith (name)
VALUES ((json_data->>'name')::character varying)
RETURNING id INTO v_id;
RETURN v_id;
END $function$
*/
}
/**
* @function catalog_monolith_d
* @memberof zzglc
* @description Catalog monolith d
* @param {integer} Key
* @returns {void}
*/
function catalog_monolith_d() {
/*
CREATE OR REPLACE FUNCTION zzglc.catalog_monolith_d("Key" integer)
RETURNS void
LANGUAGE plpgsql
AS $function$
BEGIN
DELETE FROM catalog.monolith WHERE id = "Key";
END;
$function$
*/
}
/**
* @function catalog_monolith_r
* @memberof zzglc
* @description Catalog monolith r
* @returns {Object} integer idcharacter_varying name
*/
function catalog_monolith_r() {
/*
CREATE OR REPLACE FUNCTION zzglc.catalog_monolith_r()
RETURNS TABLE(id integer, name character varying)
LANGUAGE plpgsql
AS $function$
BEGIN
RETURN QUERY (
SELECT t.id, t.name
FROM catalog.monolith t
ORDER BY 2
);
END $function$
*/
}
/**
* @function catalog_monolith_u
* @memberof zzglc
* @description Catalog monolith u
* @param {character_varying} Json
* @returns {integer}
*/
function catalog_monolith_u() {
/*
CREATE OR REPLACE FUNCTION zzglc.catalog_monolith_u("Json" character varying)
RETURNS integer
LANGUAGE plpgsql
AS $function$
DECLARE v_id integer;
DECLARE json_data json;
BEGIN
json_data := "Json";
v_id := (json_data->>'id')::integer;
UPDATE catalog.monolith SET
name = (json_data->>'name')::character varying
WHERE id = v_id;
RETURN v_id;
END $function$
*/
}
/**
* @function catalog_observation_type_c
* @memberof zzglc
* @description Catalog observation type c
* @param {character_varying} Json
* @returns {integer}
*/
function catalog_observation_type_c() {
/*
CREATE OR REPLACE FUNCTION zzglc.catalog_observation_type_c("Json" character varying)
RETURNS integer
LANGUAGE plpgsql
AS $function$
DECLARE v_id integer;
DECLARE json_data json;
BEGIN
json_data := "Json";
INSERT INTO catalog.observation_type (name)
VALUES ((json_data->>'name')::character varying)
RETURNING id INTO v_id;
RETURN v_id;
END $function$
*/
}
/**
* @function catalog_observation_type_d
* @memberof zzglc
* @description Catalog observation type d
* @param {integer} Key
* @returns {void}
*/
function catalog_observation_type_d() {
/*
CREATE OR REPLACE FUNCTION zzglc.catalog_observation_type_d("Key" integer)
RETURNS void
LANGUAGE plpgsql
AS $function$
BEGIN
DELETE FROM catalog.observation_type WHERE id = "Key";
END;
$function$
*/
}
/**
* @function catalog_observation_type_r
* @memberof zzglc
* @description Catalog observation type r
* @returns {Object} integer idcharacter_varying name
*/
function catalog_observation_type_r() {
/*
CREATE OR REPLACE FUNCTION zzglc.catalog_observation_type_r()
RETURNS TABLE(id integer, name character varying)
LANGUAGE plpgsql
AS $function$
BEGIN
RETURN QUERY (
SELECT t.id, t.name
FROM catalog.observation_type t
ORDER BY 2
);
END $function$
*/
}
/**
* @function catalog_observation_type_u
* @memberof zzglc
* @description Catalog observation type u
* @param {character_varying} Json
* @returns {void}
*/
function catalog_observation_type_u() {
/*
CREATE OR REPLACE FUNCTION zzglc.catalog_observation_type_u("Json" character varying)
RETURNS void
LANGUAGE plpgsql
AS $function$
DECLARE json_data json;
BEGIN
json_data := "Json";
UPDATE catalog.observation_type SET
name = (json_data->>'name')::character varying
WHERE id = (json_data->>'id')::integer;
END $function$
*/
}
/**
* @function catalog_preservation_c
* @memberof zzglc
* @description Catalog preservation c
* @param {character_varying} Json
* @returns {integer}
*/
function catalog_preservation_c() {
/*
CREATE OR REPLACE FUNCTION zzglc.catalog_preservation_c("Json" character varying)
RETURNS integer
LANGUAGE plpgsql
AS $function$
DECLARE v_id integer;
DECLARE json_data json;
BEGIN
json_data := "Json";
INSERT INTO catalog.preservation (name)
VALUES ((json_data->>'name')::character varying)
RETURNING id INTO v_id;
RETURN v_id;
END $function$
*/
}
/**
* @function catalog_preservation_d
* @memberof zzglc
* @description Catalog preservation d
* @param {integer} Key
* @returns {void}
*/
function catalog_preservation_d() {
/*
CREATE OR REPLACE FUNCTION zzglc.catalog_preservation_d("Key" integer)
RETURNS void
LANGUAGE plpgsql
AS $function$
BEGIN
DELETE FROM catalog.preservation WHERE id = "Key";
END;
$function$
*/
}
/**
* @function catalog_preservation_r
* @memberof zzglc
* @description Catalog preservation r
* @returns {Object} integer idcharacter_varying name
*/
function catalog_preservation_r() {
/*
CREATE OR REPLACE FUNCTION zzglc.catalog_preservation_r()
RETURNS TABLE(id integer, name character varying)
LANGUAGE plpgsql
AS $function$
BEGIN
RETURN QUERY (
SELECT t.id, t.name
FROM catalog.preservation t
ORDER BY 2
);
END $function$
*/
}
/**
* @function catalog_preservation_u
* @memberof zzglc
* @description Catalog preservation u
* @param {character_varying} Json
* @returns {integer}
*/
function catalog_preservation_u() {
/*
CREATE OR REPLACE FUNCTION zzglc.catalog_preservation_u("Json" character varying)
RETURNS integer
LANGUAGE plpgsql
AS $function$
DECLARE v_id integer;
DECLARE json_data json;
BEGIN
json_data := "Json";
v_id := (json_data->>'id')::integer;
UPDATE catalog.preservation SET
name = (json_data->>'name')::character varying
WHERE id = v_id;
RETURN v_id;
END $function$
*/
}
/**
* @function catalog_proprietor_c
* @memberof zzglc
* @description Catalog proprietor c
* @param {character_varying} Json
* @returns {integer}
*/
function catalog_proprietor_c() {
/*
CREATE OR REPLACE FUNCTION zzglc.catalog_proprietor_c("Json" character varying)
RETURNS integer
LANGUAGE plpgsql
AS $function$
DECLARE v_id integer;
DECLARE json_data json;
BEGIN
json_data := "Json";
INSERT INTO catalog.proprietor (name)
VALUES ((json_data->>'name')::character varying)
RETURNING id INTO v_id;
RETURN v_id;
END $function$
*/
}
/**
* @function catalog_proprietor_d
* @memberof zzglc
* @description Catalog proprietor d
* @param {integer} Key
* @returns {void}
*/
function catalog_proprietor_d() {
/*
CREATE OR REPLACE FUNCTION zzglc.catalog_proprietor_d("Key" integer)
RETURNS void
LANGUAGE plpgsql
AS $function$
BEGIN
DELETE FROM catalog.proprietor WHERE id = "Key";
END;
$function$
*/
}
/**
* @function catalog_proprietor_r
* @memberof zzglc
* @description Catalog proprietor r
* @returns {Object} integer idcharacter_varying name
*/
function catalog_proprietor_r() {
/*
CREATE OR REPLACE FUNCTION zzglc.catalog_proprietor_r()
RETURNS TABLE(id integer, name character varying)
LANGUAGE plpgsql
AS $function$
BEGIN
RETURN QUERY (
SELECT t.id, t.name
FROM catalog.proprietor t
ORDER BY 2
);
END $function$
*/
}
/**
* @function catalog_proprietor_u
* @memberof zzglc
* @description Catalog proprietor u
* @param {character_varying} Json
* @returns {void}
*/
function catalog_proprietor_u() {
/*
CREATE OR REPLACE FUNCTION zzglc.catalog_proprietor_u("Json" character varying)
RETURNS void
LANGUAGE plpgsql
AS $function$
DECLARE json_data json;
BEGIN
json_data := "Json";
UPDATE catalog.proprietor SET
name = (json_data->>'name')::character varying
WHERE id = (json_data->>'id')::integer;
END $function$
*/
}
/**
* @function catalog_purification_c
* @memberof zzglc
* @description Catalog purification c
* @param {character_varying} Json
* @returns {integer}
*/
function catalog_purification_c() {
/*
CREATE OR REPLACE FUNCTION zzglc.catalog_purification_c("Json" character varying)
RETURNS integer
LANGUAGE plpgsql
AS $function$
DECLARE v_id integer;
DECLARE json_data json;
BEGIN
json_data := "Json";
INSERT INTO catalog.purification (name)
VALUES ((json_data->>'name')::character varying)
RETURNING id INTO v_id;
RETURN v_id;
END $function$
*/
}
/**
* @function catalog_purification_d
* @memberof zzglc
* @description Catalog purification d
* @param {integer} Key
* @returns {void}
*/
function catalog_purification_d() {
/*
CREATE OR REPLACE FUNCTION zzglc.catalog_purification_d("Key" integer)
RETURNS void
LANGUAGE plpgsql
AS $function$
BEGIN
DELETE FROM catalog.purification WHERE id = "Key";
END;
$function$
*/
}
/**
* @function catalog_purification_r
* @memberof zzglc
* @description Catalog purification r
* @returns {Object} integer idcharacter_varying name
*/
function catalog_purification_r() {
/*
CREATE OR REPLACE FUNCTION zzglc.catalog_purification_r()
RETURNS TABLE(id integer, name character varying)
LANGUAGE plpgsql
AS $function$
BEGIN
RETURN QUERY (
SELECT t.id, t.name
FROM catalog.purification t
ORDER BY 2
);
END $function$
*/
}
/**
* @function catalog_purification_u
* @memberof zzglc
* @description Catalog purification u
* @param {character_varying} Json
* @returns {integer}
*/
function catalog_purification_u() {
/*
CREATE OR REPLACE FUNCTION zzglc.catalog_purification_u("Json" character varying)
RETURNS integer
LANGUAGE plpgsql
AS $function$
DECLARE v_id integer;
DECLARE json_data json;
BEGIN
json_data := "Json";
v_id := (json_data->>'id')::integer;
UPDATE catalog.purification SET
name = (json_data->>'name')::character varying
WHERE id = v_id;
RETURN v_id;
END $function$
*/
}
/**
* @function catalog_sample_preparation_c
* @memberof zzglc
* @description Catalog sample preparation c
* @param {character_varying} Json
* @returns {integer}
*/
function catalog_sample_preparation_c() {
/*
CREATE OR REPLACE FUNCTION zzglc.catalog_sample_preparation_c("Json" character varying)
RETURNS integer
LANGUAGE plpgsql
AS $function$
DECLARE v_id integer;
DECLARE json_data json;
BEGIN
json_data := "Json";
INSERT INTO catalog.sample_preparation (name, url, info)
VALUES ((json_data->>'name')::character varying, (json_data->>'url')::character varying, (json_data->>'info')::text)
RETURNING id INTO v_id;
RETURN v_id;
END $function$
*/
}
/**
* @function catalog_sample_preparation_d
* @memberof zzglc
* @description Catalog sample preparation d
* @param {integer} Key
* @returns {void}
*/
function catalog_sample_preparation_d() {
/*
CREATE OR REPLACE FUNCTION zzglc.catalog_sample_preparation_d("Key" integer)
RETURNS void
LANGUAGE plpgsql
AS $function$
BEGIN
DELETE FROM catalog.sample_preparation WHERE id = "Key";
END;
$function$
*/
}
/**
* @function catalog_sample_preparation_r
* @memberof zzglc
* @description Catalog sample preparation r
* @returns {Object} integer idcharacter_varying namecharacter_varying urltext info
*/
function catalog_sample_preparation_r() {
/*
CREATE OR REPLACE FUNCTION zzglc.catalog_sample_preparation_r()
RETURNS TABLE(id integer, name character varying, url character varying, info text)
LANGUAGE plpgsql
AS $function$
BEGIN
RETURN QUERY (
SELECT t.id, t.name, t.url, t.info
FROM catalog.sample_preparation t
ORDER BY 2
);
END $function$
*/
}
/**
* @function catalog_sample_preparation_u
* @memberof zzglc
* @description Catalog sample preparation u
* @param {character_varying} Json
* @returns {integer}
*/
function catalog_sample_preparation_u() {
/*
CREATE OR REPLACE FUNCTION zzglc.catalog_sample_preparation_u("Json" character varying)
RETURNS integer
LANGUAGE plpgsql
AS $function$
DECLARE v_id integer;
DECLARE json_data json;
BEGIN
json_data := "Json";
v_id := (json_data->>'id')::integer;
UPDATE catalog.sample_preparation SET
name = (json_data->>'name')::character varying,
url = (json_data->>'url')::character varying,
info = (json_data->>'info')::text
WHERE id = v_id;
RETURN v_id;
END $function$
*/
}
/**
* @function catalog_sample_type_c
* @memberof zzglc
* @description Catalog sample type c
* @param {character_varying} Json
* @returns {integer}
*/
function catalog_sample_type_c() {
/*
CREATE OR REPLACE FUNCTION zzglc.catalog_sample_type_c("Json" character varying)
RETURNS integer
LANGUAGE plpgsql
AS $function$
DECLARE v_id integer;
DECLARE json_data json;
BEGIN
json_data := "Json";
INSERT INTO catalog.sample_type (name)
VALUES ((json_data->>'name')::character varying)
RETURNING id INTO v_id;
RETURN v_id;
END $function$
*/
}
/**
* @function catalog_sample_type_d
* @memberof zzglc
* @description Catalog sample type d
* @param {integer} Key
* @returns {void}
*/
function catalog_sample_type_d() {
/*
CREATE OR REPLACE FUNCTION zzglc.catalog_sample_type_d("Key" integer)
RETURNS void
LANGUAGE plpgsql
AS $function$
BEGIN
DELETE FROM catalog.sample_type WHERE id = "Key";
END;
$function$
*/
}
/**
* @function catalog_sample_type_r
* @memberof zzglc
* @description Catalog sample type r
* @returns {Object} integer idcharacter_varying name
*/
function catalog_sample_type_r() {
/*
CREATE OR REPLACE FUNCTION zzglc.catalog_sample_type_r()
RETURNS TABLE(id integer, name character varying)
LANGUAGE plpgsql
AS $function$
BEGIN
RETURN QUERY (
SELECT t.id, t.name
FROM catalog.sample_type t
ORDER BY 2
);
END $function$
*/
}
/**
* @function catalog_sample_type_u
* @memberof zzglc
* @description Catalog sample type u
* @param {character_varying} Json
* @returns {integer}
*/
function catalog_sample_type_u() {
/*
CREATE OR REPLACE FUNCTION zzglc.catalog_sample_type_u("Json" character varying)
RETURNS integer
LANGUAGE plpgsql
AS $function$
DECLARE v_id integer;
DECLARE json_data json;
BEGIN
json_data := "Json";
v_id := (json_data->>'id')::integer;
UPDATE catalog.sample_type SET
name = (json_data->>'name')::character varying
WHERE id = v_id;
RETURN v_id;
END $function$
*/
}
/**
* @function catalog_sequence_reference_library_c
* @memberof zzglc
* @description Catalog sequence reference library c
* @param {character_varying} Json
* @returns {integer}
*/
function catalog_sequence_reference_library_c() {
/*
CREATE OR REPLACE FUNCTION zzglc.catalog_sequence_reference_library_c("Json" character varying)
RETURNS integer
LANGUAGE plpgsql
AS $function$
DECLARE v_id integer;
DECLARE json_data json;
BEGIN
json_data := "Json";
INSERT INTO catalog.sequence_reference_library (name, url)
VALUES ((json_data->>'name')::character varying, (json_data->>'url')::character varying)
RETURNING id INTO v_id;
RETURN v_id;
END $function$
*/
}
/**
* @function catalog_sequence_reference_library_d
* @memberof zzglc
* @description Catalog sequence reference library d
* @param {integer} Key
* @returns {void}
*/
function catalog_sequence_reference_library_d() {
/*
CREATE OR REPLACE FUNCTION zzglc.catalog_sequence_reference_library_d("Key" integer)
RETURNS void
LANGUAGE plpgsql
AS $function$
BEGIN
DELETE FROM catalog.sequence_reference_library WHERE id = "Key";
END;
$function$
*/
}
/**
* @function catalog_sequence_reference_library_r
* @memberof zzglc
* @description Catalog sequence reference library r
* @returns {Object} integer idcharacter_varying namecharacter_varying url
*/
function catalog_sequence_reference_library_r() {
/*
CREATE OR REPLACE FUNCTION zzglc.catalog_sequence_reference_library_r()
RETURNS TABLE(id integer, name character varying, url character varying)
LANGUAGE plpgsql
AS $function$
BEGIN
RETURN QUERY (
SELECT t.id, t.name, t.url
FROM catalog.sequence_reference_library t
ORDER BY 2
);
END $function$
*/
}
/**
* @function catalog_sequence_reference_library_u
* @memberof zzglc
* @description Catalog sequence reference library u
* @param {character_varying} Json
* @returns {integer}
*/
function catalog_sequence_reference_library_u() {
/*
CREATE OR REPLACE FUNCTION zzglc.catalog_sequence_reference_library_u("Json" character varying)
RETURNS integer
LANGUAGE plpgsql
AS $function$
DECLARE v_id integer;
DECLARE json_data json;
BEGIN
json_data := "Json";
v_id := (json_data->>'id')::integer;
UPDATE catalog.sequence_reference_library SET
name = (json_data->>'name')::character varying,
url = (json_data->>'url')::character varying
WHERE id = v_id;
RETURN v_id;
END $function$
*/
}
/**
* @function catalog_sequencing_c
* @memberof zzglc
* @description Catalog sequencing c
* @param {character_varying} Json
* @returns {integer}
*/
function catalog_sequencing_c() {
/*
CREATE OR REPLACE FUNCTION zzglc.catalog_sequencing_c("Json" character varying)
RETURNS integer
LANGUAGE plpgsql
AS $function$
DECLARE v_id integer;
DECLARE json_data json;
BEGIN
json_data := "Json";
INSERT INTO catalog.sequencing (name)
VALUES ((json_data->>'name')::character varying)
RETURNING id INTO v_id;
RETURN v_id;
END $function$
*/
}
/**
* @function catalog_sequencing_d
* @memberof zzglc
* @description Catalog sequencing d
* @param {integer} Key
* @returns {void}
*/
function catalog_sequencing_d() {
/*
CREATE OR REPLACE FUNCTION zzglc.catalog_sequencing_d("Key" integer)
RETURNS void
LANGUAGE plpgsql
AS $function$
BEGIN
DELETE FROM catalog.sequencing WHERE id = "Key";
END;
$function$
*/
}
/**
* @function catalog_sequencing_r
* @memberof zzglc
* @description Catalog sequencing r
* @returns {Object} integer idcharacter_varying name
*/
function catalog_sequencing_r() {
/*
CREATE OR REPLACE FUNCTION zzglc.catalog_sequencing_r()
RETURNS TABLE(id integer, name character varying)
LANGUAGE plpgsql
AS $function$
BEGIN
RETURN QUERY (
SELECT t.id, t.name
FROM catalog.sequencing t
ORDER BY 2
);
END $function$
*/
}
/**
* @function catalog_sequencing_u
* @memberof zzglc
* @description Catalog sequencing u
* @param {character_varying} Json
* @returns {integer}
*/
function catalog_sequencing_u() {
/*
CREATE OR REPLACE FUNCTION zzglc.catalog_sequencing_u("Json" character varying)
RETURNS integer
LANGUAGE plpgsql
AS $function$
DECLARE v_id integer;
DECLARE json_data json;
BEGIN
json_data := "Json";
v_id := (json_data->>'id')::integer;
UPDATE catalog.sequencing SET
name = (json_data->>'name')::character varying
WHERE id = v_id;
RETURN v_id;
END $function$
*/
}
/**
* @function catalog_simple_observation_c
* @memberof zzglc
* @description Catalog simple observation c
* @param {character_varying} Json
* @returns {integer}
*/
function catalog_simple_observation_c() {
/*
CREATE OR REPLACE FUNCTION zzglc.catalog_simple_observation_c("Json" character varying)
RETURNS integer
LANGUAGE plpgsql
AS $function$
DECLARE v_id integer;
DECLARE json_data json;
BEGIN
json_data := "Json";
INSERT INTO catalog.simple_observation (name)
VALUES ((json_data->>'name')::character varying)
RETURNING id INTO v_id;
RETURN v_id;
END $function$
*/
}
/**
* @function catalog_simple_observation_d
* @memberof zzglc
* @description Catalog simple observation d
* @param {integer} Key
* @returns {void}
*/
function catalog_simple_observation_d() {
/*
CREATE OR REPLACE FUNCTION zzglc.catalog_simple_observation_d("Key" integer)
RETURNS void
LANGUAGE plpgsql
AS $function$
BEGIN
DELETE FROM catalog.simple_observation WHERE id = "Key";
END;
$function$
*/
}
/**
* @function catalog_simple_observation_r
* @memberof zzglc
* @description Catalog simple observation r
* @returns {Object} integer idcharacter_varying name
*/
function catalog_simple_observation_r() {
/*
CREATE OR REPLACE FUNCTION zzglc.catalog_simple_observation_r()
RETURNS TABLE(id integer, name character varying)
LANGUAGE plpgsql
AS $function$
BEGIN
RETURN QUERY (
SELECT t.id, t.name
FROM catalog.simple_observation t
ORDER BY 2
);
END $function$
*/
}
/**
* @function catalog_simple_observation_u
* @memberof zzglc
* @description Catalog simple observation u
* @param {character_varying} Json
* @returns {void}
*/
function catalog_simple_observation_u() {
/*
CREATE OR REPLACE FUNCTION zzglc.catalog_simple_observation_u("Json" character varying)
RETURNS void
LANGUAGE plpgsql
AS $function$
DECLARE json_data json;
BEGIN
json_data := "Json";
UPDATE catalog.simple_observation SET
name = (json_data->>'name')::character varying
WHERE id = (json_data->>'id')::integer;
END $function$
*/
}
/**
* @function catalog_sky_condition_c
* @memberof zzglc
* @description Catalog sky condition c
* @param {character_varying} Json
* @returns {integer}
*/
function catalog_sky_condition_c() {
/*
CREATE OR REPLACE FUNCTION zzglc.catalog_sky_condition_c("Json" character varying)
RETURNS integer
LANGUAGE plpgsql
AS $function$
DECLARE v_id integer;
DECLARE json_data json;
BEGIN
json_data := "Json";
INSERT INTO catalog.sky_condition (name)
VALUES ((json_data->>'name')::character varying)
RETURNING id INTO v_id;
RETURN v_id;
END $function$
*/
}
/**
* @function catalog_sky_condition_d
* @memberof zzglc
* @description Catalog sky condition d
* @param {integer} Key
* @returns {void}
*/
function catalog_sky_condition_d() {
/*
CREATE OR REPLACE FUNCTION zzglc.catalog_sky_condition_d("Key" integer)
RETURNS void
LANGUAGE plpgsql
AS $function$
BEGIN
DELETE FROM catalog.sky_condition WHERE id = "Key";
END;
$function$
*/
}
/**
* @function catalog_sky_condition_r
* @memberof zzglc
* @description Catalog sky condition r
* @returns {Object} integer idcharacter_varying name
*/
function catalog_sky_condition_r() {
/*
CREATE OR REPLACE FUNCTION zzglc.catalog_sky_condition_r()
RETURNS TABLE(id integer, name character varying)
LANGUAGE plpgsql
AS $function$
BEGIN
RETURN QUERY (
SELECT t.id, t.name
FROM catalog.sky_condition t
ORDER BY 2
);
END $function$
*/
}
/**
* @function catalog_sky_condition_u
* @memberof zzglc
* @description Catalog sky condition u
* @param {character_varying} Json
* @returns {integer}
*/
function catalog_sky_condition_u() {
/*
CREATE OR REPLACE FUNCTION zzglc.catalog_sky_condition_u("Json" character varying)
RETURNS integer
LANGUAGE plpgsql
AS $function$
DECLARE v_id integer;
DECLARE json_data json;
BEGIN
json_data := "Json";
v_id := (json_data->>'id')::integer;
UPDATE catalog.sky_condition SET
name = (json_data->>'name')::character varying
WHERE id = v_id;
RETURN v_id;
END $function$
*/
}
/**
* @function catalog_soil_class_c
* @memberof zzglc
* @description Catalog soil class c
* @param {character_varying} Json
* @returns {integer}
*/
function catalog_soil_class_c() {
/*
CREATE OR REPLACE FUNCTION zzglc.catalog_soil_class_c("Json" character varying)
RETURNS integer
LANGUAGE plpgsql
AS $function$
DECLARE v_id integer;
DECLARE json_data json;
BEGIN
json_data := "Json";
INSERT INTO catalog.soil_class (name)
VALUES ((json_data->>'name')::character varying)
RETURNING id INTO v_id;
RETURN v_id;
END $function$
*/
}
/**
* @function catalog_soil_class_d
* @memberof zzglc
* @description Catalog soil class d
* @param {integer} Key
* @returns {void}
*/
function catalog_soil_class_d() {
/*
CREATE OR REPLACE FUNCTION zzglc.catalog_soil_class_d("Key" integer)
RETURNS void
LANGUAGE plpgsql
AS $function$
BEGIN
DELETE FROM catalog.soil_class WHERE id = "Key";
END;
$function$
*/
}
/**
* @function catalog_soil_class_r
* @memberof zzglc
* @description Catalog soil class r
* @returns {Object} integer idcharacter_varying name
*/
function catalog_soil_class_r() {
/*
CREATE OR REPLACE FUNCTION zzglc.catalog_soil_class_r()
RETURNS TABLE(id integer, name character varying)
LANGUAGE plpgsql
AS $function$
BEGIN
RETURN QUERY (
SELECT t.id, t.name
FROM catalog.soil_class t
ORDER BY 2
);
END $function$
*/
}
/**
* @function catalog_soil_class_u
* @memberof zzglc
* @description Catalog soil class u
* @param {character_varying} Json
* @returns {integer}
*/
function catalog_soil_class_u() {
/*
CREATE OR REPLACE FUNCTION zzglc.catalog_soil_class_u("Json" character varying)
RETURNS integer
LANGUAGE plpgsql
AS $function$
DECLARE v_id integer;
DECLARE json_data json;
BEGIN
json_data := "Json";
v_id := (json_data->>'id')::integer;
UPDATE catalog.soil_class SET
name = (json_data->>'name')::character varying
WHERE id = v_id;
RETURN v_id;
END $function$
*/
}
/**
* @function catalog_soil_moisture_method_c
* @memberof zzglc
* @description Catalog soil moisture method c
* @param {character_varying} Json
* @returns {integer}
*/
function catalog_soil_moisture_method_c() {
/*
CREATE OR REPLACE FUNCTION zzglc.catalog_soil_moisture_method_c("Json" character varying)
RETURNS integer
LANGUAGE plpgsql
AS $function$
DECLARE v_id integer;
DECLARE json_data json;
BEGIN
json_data := "Json";
INSERT INTO catalog.soil_moisture_method (name)
VALUES ((json_data->>'name')::character varying)
RETURNING id INTO v_id;
RETURN v_id;
END $function$
*/
}
/**
* @function catalog_soil_moisture_method_d
* @memberof zzglc
* @description Catalog soil moisture method d
* @param {integer} Key
* @returns {void}
*/
function catalog_soil_moisture_method_d() {
/*
CREATE OR REPLACE FUNCTION zzglc.catalog_soil_moisture_method_d("Key" integer)
RETURNS void
LANGUAGE plpgsql
AS $function$
BEGIN
DELETE FROM catalog.soil_moisture_method WHERE id = "Key";
END;
$function$
*/
}
/**
* @function catalog_soil_moisture_method_r
* @memberof zzglc
* @description Catalog soil moisture method r
* @returns {Object} integer idcharacter_varying name
*/
function catalog_soil_moisture_method_r() {
/*
CREATE OR REPLACE FUNCTION zzglc.catalog_soil_moisture_method_r()
RETURNS TABLE(id integer, name character varying)
LANGUAGE plpgsql
AS $function$
BEGIN
RETURN QUERY (
SELECT t.id, t.name
FROM catalog.soil_moisture_method t
ORDER BY 2
);
END $function$
*/
}
/**
* @function catalog_soil_moisture_method_u
* @memberof zzglc
* @description Catalog soil moisture method u
* @param {character_varying} Json
* @returns {integer}
*/
function catalog_soil_moisture_method_u() {
/*
CREATE OR REPLACE FUNCTION zzglc.catalog_soil_moisture_method_u("Json" character varying)
RETURNS integer
LANGUAGE plpgsql
AS $function$
DECLARE v_id integer;
DECLARE json_data json;
BEGIN
json_data := "Json";
v_id := (json_data->>'id')::integer;
UPDATE catalog.soil_moisture_method SET
name = (json_data->>'name')::character varying
WHERE id = v_id;
RETURN v_id;
END $function$
*/
}
/**
* @function catalog_spectroscopy_method_c
* @memberof zzglc
* @description Catalog spectroscopy method c
* @param {character_varying} Json
* @returns {integer}
*/
function catalog_spectroscopy_method_c() {
/*
CREATE OR REPLACE FUNCTION zzglc.catalog_spectroscopy_method_c("Json" character varying)
RETURNS integer
LANGUAGE plpgsql
AS $function$
DECLARE v_id integer;
DECLARE json_data json;
BEGIN
json_data := "Json";
INSERT INTO catalog.spectroscopy_method (name)
VALUES ((json_data->>'name')::character varying)
RETURNING id INTO v_id;
RETURN v_id;
END $function$
*/
}
/**
* @function catalog_spectroscopy_method_d
* @memberof zzglc
* @description Catalog spectroscopy method d
* @param {integer} Key
* @returns {void}
*/
function catalog_spectroscopy_method_d() {
/*
CREATE OR REPLACE FUNCTION zzglc.catalog_spectroscopy_method_d("Key" integer)
RETURNS void
LANGUAGE plpgsql
AS $function$
BEGIN
DELETE FROM catalog.spectroscopy_method WHERE id = "Key";
END;
$function$
*/
}
/**
* @function catalog_spectroscopy_method_r
* @memberof zzglc
* @description Catalog spectroscopy method r
* @returns {Object} integer idcharacter_varying name
*/
function catalog_spectroscopy_method_r() {
/*
CREATE OR REPLACE FUNCTION zzglc.catalog_spectroscopy_method_r()
RETURNS TABLE(id integer, name character varying)
LANGUAGE plpgsql
AS $function$
BEGIN
RETURN QUERY (
SELECT t.id, t.name
FROM catalog.spectroscopy_method t
ORDER BY 2
);
END $function$
*/
}
/**
* @function catalog_spectroscopy_method_u
* @memberof zzglc
* @description Catalog spectroscopy method u
* @param {character_varying} Json
* @returns {integer}
*/
function catalog_spectroscopy_method_u() {
/*
CREATE OR REPLACE FUNCTION zzglc.catalog_spectroscopy_method_u("Json" character varying)
RETURNS integer
LANGUAGE plpgsql
AS $function$
DECLARE v_id integer;
DECLARE json_data json;
BEGIN
json_data := "Json";
v_id := (json_data->>'id')::integer;
UPDATE catalog.spectroscopy_method SET
name = (json_data->>'name')::character varying
WHERE id = v_id;
RETURN v_id;
END $function$
*/
}
/**
* @function catalog_storage_c
* @memberof zzglc
* @description Catalog storage c
* @param {character_varying} Json
* @returns {integer}
*/
function catalog_storage_c() {
/*
CREATE OR REPLACE FUNCTION zzglc.catalog_storage_c("Json" character varying)
RETURNS integer
LANGUAGE plpgsql
AS $function$
DECLARE v_id integer;
DECLARE json_data json;
BEGIN
json_data := "Json";
INSERT INTO catalog.storage (name)
VALUES ((json_data->>'name')::character varying)
RETURNING id INTO v_id;
RETURN v_id;
END $function$
*/
}
/**
* @function catalog_storage_d
* @memberof zzglc
* @description Catalog storage d
* @param {integer} Key
* @returns {void}
*/
function catalog_storage_d() {
/*
CREATE OR REPLACE FUNCTION zzglc.catalog_storage_d("Key" integer)
RETURNS void
LANGUAGE plpgsql
AS $function$
BEGIN
DELETE FROM catalog.storage WHERE id = "Key";
END;
$function$
*/
}
/**
* @function catalog_storage_r
* @memberof zzglc
* @description Catalog storage r
* @returns {Object} integer idcharacter_varying name
*/
function catalog_storage_r() {
/*
CREATE OR REPLACE FUNCTION zzglc.catalog_storage_r()
RETURNS TABLE(id integer, name character varying)
LANGUAGE plpgsql
AS $function$
BEGIN
RETURN QUERY (
SELECT t.id, t.name
FROM catalog.storage t
ORDER BY 2
);
END $function$
*/
}
/**
* @function catalog_storage_u
* @memberof zzglc
* @description Catalog storage u
* @param {character_varying} Json
* @returns {integer}
*/
function catalog_storage_u() {
/*
CREATE OR REPLACE FUNCTION zzglc.catalog_storage_u("Json" character varying)
RETURNS integer
LANGUAGE plpgsql
AS $function$
DECLARE v_id integer;
DECLARE json_data json;
BEGIN
json_data := "Json";
v_id := (json_data->>'id')::integer;
UPDATE catalog.storage SET
name = (json_data->>'name')::character varying
WHERE id = v_id;
RETURN v_id;
END $function$
*/
}
/**
* @function catalog_taxa_code_c
* @memberof zzglc
* @description Catalog taxa code c
* @param {character_varying} Json
* @returns {integer}
*/
function catalog_taxa_code_c() {
/*
CREATE OR REPLACE FUNCTION zzglc.catalog_taxa_code_c("Json" character varying)
RETURNS integer
LANGUAGE plpgsql
AS $function$
DECLARE v_id integer;
DECLARE json_data json;
BEGIN
json_data := "Json";
INSERT INTO catalog.taxa_code (name)
VALUES ((json_data->>'name')::text)
RETURNING id INTO v_id;
RETURN v_id;
END $function$
*/
}
/**
* @function catalog_taxa_code_d
* @memberof zzglc
* @description Catalog taxa code d
* @param {integer} Key
* @returns {void}
*/
function catalog_taxa_code_d() {
/*
CREATE OR REPLACE FUNCTION zzglc.catalog_taxa_code_d("Key" integer)
RETURNS void
LANGUAGE plpgsql
AS $function$
BEGIN
DELETE FROM catalog.taxa_code WHERE id = "Key";
END;
$function$
*/
}
/**
* @function catalog_taxa_code_r
* @memberof zzglc
* @description Catalog taxa code r
* @returns {Object} integer idtext name
*/
function catalog_taxa_code_r() {
/*
CREATE OR REPLACE FUNCTION zzglc.catalog_taxa_code_r()
RETURNS TABLE(id integer, name text)
LANGUAGE plpgsql
AS $function$
BEGIN
RETURN QUERY (
SELECT t.id, t.name
FROM catalog.taxa_code t
ORDER BY 2
);
END $function$
*/
}
/**
* @function catalog_taxa_code_u
* @memberof zzglc
* @description Catalog taxa code u
* @param {character_varying} Json
* @returns {integer}
*/
function catalog_taxa_code_u() {
/*
CREATE OR REPLACE FUNCTION zzglc.catalog_taxa_code_u("Json" character varying)
RETURNS integer
LANGUAGE plpgsql
AS $function$
DECLARE v_id integer;
DECLARE json_data json;
BEGIN
json_data := "Json";
v_id := (json_data->>'id')::integer;
UPDATE catalog.taxa_code SET
name = (json_data->>'name')::text
WHERE id = v_id;
RETURN v_id;
END $function$
*/
}
/**
* @function catalog_taxa_level_c
* @memberof zzglc
* @description Catalog taxa level c
* @param {character_varying} Json
* @returns {integer}
*/
function catalog_taxa_level_c() {
/*
CREATE OR REPLACE FUNCTION zzglc.catalog_taxa_level_c("Json" character varying)
RETURNS integer
LANGUAGE plpgsql
AS $function$
DECLARE v_id integer;
DECLARE json_data json;
BEGIN
json_data := "Json";
INSERT INTO catalog.taxa_level (name)
VALUES ((json_data->>'name')::character varying)
RETURNING id INTO v_id;
RETURN v_id;
END $function$
*/
}
/**
* @function catalog_taxa_level_d
* @memberof zzglc
* @description Catalog taxa level d
* @param {integer} Key
* @returns {void}
*/
function catalog_taxa_level_d() {
/*
CREATE OR REPLACE FUNCTION zzglc.catalog_taxa_level_d("Key" integer)
RETURNS void
LANGUAGE plpgsql
AS $function$
BEGIN
DELETE FROM catalog.taxa_level WHERE id = "Key";
END;
$function$
*/
}
/**
* @function catalog_taxa_level_r
* @memberof zzglc
* @description Catalog taxa level r
* @returns {Object} integer idcharacter_varying name
*/
function catalog_taxa_level_r() {
/*
CREATE OR REPLACE FUNCTION zzglc.catalog_taxa_level_r()
RETURNS TABLE(id integer, name character varying)
LANGUAGE plpgsql
AS $function$
BEGIN
RETURN QUERY (
SELECT t.id, t.name
FROM catalog.taxa_level t
ORDER BY 2
);
END $function$
*/
}
/**
* @function catalog_taxa_level_u
* @memberof zzglc
* @description Catalog taxa level u
* @param {character_varying} Json
* @returns {integer}
*/
function catalog_taxa_level_u() {
/*
CREATE OR REPLACE FUNCTION zzglc.catalog_taxa_level_u("Json" character varying)
RETURNS integer
LANGUAGE plpgsql
AS $function$
DECLARE v_id integer;
DECLARE json_data json;
BEGIN
json_data := "Json";
v_id := (json_data->>'id')::integer;
UPDATE catalog.taxa_level SET
name = (json_data->>'name')::character varying
WHERE id = v_id;
RETURN v_id;
END $function$
*/
}
/**
* @function catalog_taxa_status_c
* @memberof zzglc
* @description Catalog taxa status c
* @param {character_varying} Json
* @returns {integer}
*/
function catalog_taxa_status_c() {
/*
CREATE OR REPLACE FUNCTION zzglc.catalog_taxa_status_c("Json" character varying)
RETURNS integer
LANGUAGE plpgsql
AS $function$
DECLARE v_id integer;
DECLARE json_data json;
BEGIN
json_data := "Json";
INSERT INTO catalog.taxa_status (name)
VALUES ((json_data->>'name')::character varying)
RETURNING id INTO v_id;
RETURN v_id;
END $function$
*/
}
/**
* @function catalog_taxa_status_d
* @memberof zzglc
* @description Catalog taxa status d
* @param {integer} Key
* @returns {void}
*/
function catalog_taxa_status_d() {
/*
CREATE OR REPLACE FUNCTION zzglc.catalog_taxa_status_d("Key" integer)
RETURNS void
LANGUAGE plpgsql
AS $function$
BEGIN
DELETE FROM catalog.taxa_status WHERE id = "Key";
END;
$function$
*/
}
/**
* @function catalog_taxa_status_r
* @memberof zzglc
* @description Catalog taxa status r
* @returns {Object} integer idcharacter_varying name
*/
function catalog_taxa_status_r() {
/*
CREATE OR REPLACE FUNCTION zzglc.catalog_taxa_status_r()
RETURNS TABLE(id integer, name character varying)
LANGUAGE plpgsql
AS $function$
BEGIN
RETURN QUERY (
SELECT t.id, t.name
FROM catalog.taxa_status t
ORDER BY 2
);
END $function$
*/
}
/**
* @function catalog_taxa_status_u
* @memberof zzglc
* @description Catalog taxa status u
* @param {character_varying} Json
* @returns {integer}
*/
function catalog_taxa_status_u() {
/*
CREATE OR REPLACE FUNCTION zzglc.catalog_taxa_status_u("Json" character varying)
RETURNS integer
LANGUAGE plpgsql
AS $function$
DECLARE v_id integer;
DECLARE json_data json;
BEGIN
json_data := "Json";
v_id := (json_data->>'id')::integer;
UPDATE catalog.taxa_status SET
name = (json_data->>'name')::character varying
WHERE id = v_id;
RETURN v_id;
END $function$
*/
}
/**
* @function catalog_transport_c
* @memberof zzglc
* @description Catalog transport c
* @param {character_varying} Json
* @returns {integer}
*/
function catalog_transport_c() {
/*
CREATE OR REPLACE FUNCTION zzglc.catalog_transport_c("Json" character varying)
RETURNS integer
LANGUAGE plpgsql
AS $function$
DECLARE v_id integer;
DECLARE json_data json;
BEGIN
json_data := "Json";
INSERT INTO catalog.transport (name)
VALUES ((json_data->>'name')::character varying)
RETURNING id INTO v_id;
RETURN v_id;
END $function$
*/
}
/**
* @function catalog_transport_d
* @memberof zzglc
* @description Catalog transport d
* @param {integer} Key
* @returns {void}
*/
function catalog_transport_d() {
/*
CREATE OR REPLACE FUNCTION zzglc.catalog_transport_d("Key" integer)
RETURNS void
LANGUAGE plpgsql
AS $function$
BEGIN
DELETE FROM catalog.transport WHERE id = "Key";
END;
$function$
*/
}
/**
* @function catalog_transport_r
* @memberof zzglc
* @description Catalog transport r
* @returns {Object} integer idcharacter_varying name
*/
function catalog_transport_r() {
/*
CREATE OR REPLACE FUNCTION zzglc.catalog_transport_r()
RETURNS TABLE(id integer, name character varying)
LANGUAGE plpgsql
AS $function$
BEGIN
RETURN QUERY (
SELECT t.id, t.name
FROM catalog.transport t
ORDER BY 2
);
END $function$
*/
}
/**
* @function catalog_transport_u
* @memberof zzglc
* @description Catalog transport u
* @param {character_varying} Json
* @returns {integer}
*/
function catalog_transport_u() {
/*
CREATE OR REPLACE FUNCTION zzglc.catalog_transport_u("Json" character varying)
RETURNS integer
LANGUAGE plpgsql
AS $function$
DECLARE v_id integer;
DECLARE json_data json;
BEGIN
json_data := "Json";
v_id := (json_data->>'id')::integer;
UPDATE catalog.transport SET
name = (json_data->>'name')::character varying
WHERE id = v_id;
RETURN v_id;
END $function$
*/
}
/**
* @function catalog_unit_c
* @memberof zzglc
* @description Catalog unit c
* @param {character_varying} Json
* @returns {integer}
*/
function catalog_unit_c() {
/*
CREATE OR REPLACE FUNCTION zzglc.catalog_unit_c("Json" character varying)
RETURNS integer
LANGUAGE plpgsql
AS $function$
DECLARE v_id integer;
DECLARE json_data json;
BEGIN
json_data := "Json";
INSERT INTO catalog.unit (display_name, name, name_match)
VALUES ((json_data->>'display_name')::character varying, (json_data->>'name')::character varying, (json_data->>'name_match')::character varying)
RETURNING id INTO v_id;
RETURN v_id;
END $function$
*/
}
/**
* @function catalog_unit_d
* @memberof zzglc
* @description Catalog unit d
* @param {integer} Key
* @returns {void}
*/
function catalog_unit_d() {
/*
CREATE OR REPLACE FUNCTION zzglc.catalog_unit_d("Key" integer)
RETURNS void
LANGUAGE plpgsql
AS $function$
BEGIN
DELETE FROM catalog.unit WHERE id = "Key";
END;
$function$
*/
}
/**
* @function catalog_unit_r
* @memberof zzglc
* @description Catalog unit r
* @returns {Object} integer idcharacter_varying display_namecharacter_varying namecharacter_varying name_match
*/
function catalog_unit_r() {
/*
CREATE OR REPLACE FUNCTION zzglc.catalog_unit_r()
RETURNS TABLE(id integer, display_name character varying, name character varying, name_match character varying)
LANGUAGE plpgsql
AS $function$
BEGIN
RETURN QUERY (
SELECT t.id, t.display_name, t.name, t.name_match
FROM catalog.unit t
ORDER BY 2
);
END $function$
*/
}
/**
* @function catalog_unit_u
* @memberof zzglc
* @description Catalog unit u
* @param {character_varying} Json
* @returns {integer}
*/
function catalog_unit_u() {
/*
CREATE OR REPLACE FUNCTION zzglc.catalog_unit_u("Json" character varying)
RETURNS integer
LANGUAGE plpgsql
AS $function$
DECLARE v_id integer;
DECLARE json_data json;
BEGIN
json_data := "Json";
v_id := (json_data->>'id')::integer;
UPDATE catalog.unit SET
display_name = (json_data->>'display_name')::character varying,
name = (json_data->>'name')::character varying,
name_match = (json_data->>'name_match')::character varying
WHERE id = v_id;
RETURN v_id;
END $function$
*/
}
/**
* @function catalog_usda_standard_c
* @memberof zzglc
* @description Catalog usda standard c
* @param {character_varying} Json
* @returns {integer}
*/
function catalog_usda_standard_c() {
/*
CREATE OR REPLACE FUNCTION zzglc.catalog_usda_standard_c("Json" character varying)
RETURNS integer
LANGUAGE plpgsql
AS $function$
DECLARE v_id integer;
DECLARE json_data json;
BEGIN
json_data := "Json";
INSERT INTO catalog.usda_standard (name)
VALUES ((json_data->>'name')::character varying)
RETURNING id INTO v_id;
RETURN v_id;
END $function$
*/
}
/**
* @function catalog_usda_standard_d
* @memberof zzglc
* @description Catalog usda standard d
* @param {integer} Key
* @returns {void}
*/
function catalog_usda_standard_d() {
/*
CREATE OR REPLACE FUNCTION zzglc.catalog_usda_standard_d("Key" integer)
RETURNS void
LANGUAGE plpgsql
AS $function$
BEGIN
DELETE FROM catalog.usda_standard WHERE id = "Key";
END;
$function$
*/
}
/**
* @function catalog_usda_standard_r
* @memberof zzglc
* @description Catalog usda standard r
* @returns {Object} integer idcharacter_varying name
*/
function catalog_usda_standard_r() {
/*
CREATE OR REPLACE FUNCTION zzglc.catalog_usda_standard_r()
RETURNS TABLE(id integer, name character varying)
LANGUAGE plpgsql
AS $function$
BEGIN
RETURN QUERY (
SELECT t.id, t.name
FROM catalog.usda_standard t
ORDER BY 2
);
END $function$
*/
}
/**
* @function catalog_usda_standard_u
* @memberof zzglc
* @description Catalog usda standard u
* @param {character_varying} Json
* @returns {void}
*/
function catalog_usda_standard_u() {
/*
CREATE OR REPLACE FUNCTION zzglc.catalog_usda_standard_u("Json" character varying)
RETURNS void
LANGUAGE plpgsql
AS $function$
DECLARE json_data json;
BEGIN
json_data := "Json";
UPDATE catalog.usda_standard SET
name = (json_data->>'name')::character varying
WHERE id = (json_data->>'id')::integer;
END $function$
*/
}
/**
* @function data_aggregate_region_c
* @memberof zzglc
* @description Data aggregate region c
* @param {character_varying} Json
* @returns {integer}
*/
function data_aggregate_region_c() {
/*
CREATE OR REPLACE FUNCTION zzglc.data_aggregate_region_c("Json" character varying)
RETURNS integer
LANGUAGE plpgsql
AS $function$
DECLARE v_id integer;
DECLARE json_data json;
BEGIN
json_data := "Json";
INSERT INTO data.aggregate_region (key, environmental_zone_id, soil_type_id, environmental_zone_code, soil_type_code)
VALUES ((json_data->>'key')::character varying, (json_data->>'environmental_zone_id')::integer, (json_data->>'soil_type_id')::integer, (json_data->>'environmental_zone_code')::character varying, (json_data->>'soil_type_code')::character varying)
RETURNING id INTO v_id;
RETURN v_id;
END $function$
*/
}
/**
* @function data_aggregate_region_d
* @memberof zzglc
* @description Data aggregate region d
* @param {integer} Key
* @returns {void}
*/
function data_aggregate_region_d() {
/*
CREATE OR REPLACE FUNCTION zzglc.data_aggregate_region_d("Key" integer)
RETURNS void
LANGUAGE plpgsql
AS $function$
BEGIN
DELETE FROM data.aggregate_region WHERE id = "Key";
END;
$function$
*/
}
/**
* @function data_aggregate_region_r
* @memberof zzglc
* @description Data aggregate region r
* @returns {Object} integer idcharacter_varying keyinteger catalog_environmental_zone__environmental_zone_idinteger catalog_soil_type__soil_type_idcharacter_varying environmental_zone_codecharacter_varying soil_type_codecharacter_varying catalog_environmental_zone__environmental_zone_id_valcharacter_varying catalog_soil_type__soil_type_id_val
*/
function data_aggregate_region_r() {
/*
CREATE OR REPLACE FUNCTION zzglc.data_aggregate_region_r()
RETURNS TABLE(id integer, key character varying, catalog_environmental_zone__environmental_zone_id integer, catalog_soil_type__soil_type_id integer, environmental_zone_code character varying, soil_type_code character varying, catalog_environmental_zone__environmental_zone_id_val character varying, catalog_soil_type__soil_type_id_val character varying)
LANGUAGE plpgsql
AS $function$
BEGIN
RETURN QUERY (
SELECT t.id, t.key, t.environmental_zone_id, t.soil_type_id, t.environmental_zone_code, t.soil_type_code, environmental_zone_id.name, soil_type_id.name
FROM data.aggregate_region t
LEFT JOIN catalog.environmental_zone environmental_zone_id ON environmental_zone_id.id = t.environmental_zone_id
LEFT JOIN catalog.soil_type soil_type_id ON soil_type_id.id = t.soil_type_id
ORDER BY 2
);
END $function$
*/
}
/**
* @function data_aggregate_region_u
* @memberof zzglc
* @description Data aggregate region u
* @param {character_varying} Json
* @returns {integer}
*/
function data_aggregate_region_u() {
/*
CREATE OR REPLACE FUNCTION zzglc.data_aggregate_region_u("Json" character varying)
RETURNS integer
LANGUAGE plpgsql
AS $function$
DECLARE v_id integer;
DECLARE json_data json;
BEGIN
json_data := "Json";
v_id := (json_data->>'id')::integer;
UPDATE data.aggregate_region SET
key = (json_data->>'key')::character varying,
environmental_zone_id = (json_data->>'environmental_zone_id')::integer,
soil_type_id = (json_data->>'soil_type_id')::integer,
environmental_zone_code = (json_data->>'environmental_zone_code')::character varying,
soil_type_code = (json_data->>'soil_type_code')::character varying
WHERE id = v_id;
RETURN v_id;
END $function$
*/
}
/**
* @function data_aggregate_stability_c
* @memberof zzglc
* @description Data aggregate stability c
* @param {character_varying} Json
* @returns {integer}
*/
function data_aggregate_stability_c() {
/*
CREATE OR REPLACE FUNCTION zzglc.data_aggregate_stability_c("Json" character varying)
RETURNS integer
LANGUAGE plpgsql
AS $function$
DECLARE v_id integer;
DECLARE json_data json;
BEGIN
json_data := "Json";
INSERT INTO data.aggregate_stability (app_version, aggregate_stability_index, observation_id, aggregate_stability_app_id)
VALUES ((json_data->>'app_version')::character varying, (json_data->>'aggregate_stability_index')::double precision, (json_data->>'observation_id')::integer, (json_data->>'aggregate_stability_app_id')::integer)
RETURNING id INTO v_id;
RETURN v_id;
END $function$
*/
}
/**
* @function data_aggregate_stability_d
* @memberof zzglc
* @description Data aggregate stability d
* @param {integer} Key
* @returns {void}
*/
function data_aggregate_stability_d() {
/*
CREATE OR REPLACE FUNCTION zzglc.data_aggregate_stability_d("Key" integer)
RETURNS void
LANGUAGE plpgsql
AS $function$
BEGIN
DELETE FROM data.aggregate_stability WHERE id = "Key";
END;
$function$
*/
}
/**
* @function data_aggregate_stability_r
* @memberof zzglc
* @description Data aggregate stability r
* @param {integer} Key
* @returns {Object} integer idcharacter_varying app_versiondouble_precision aggregate_stability_indexinteger data_observation__observation_idinteger catalog_aggregate_stability_app__aggregate_stability_app_idcharacter_varying data_observation__observation_id_valcharacter_varying catalog_aggregate_stability_app__aggregate_stability_app_id_val
*/
function data_aggregate_stability_r() {
/*
CREATE OR REPLACE FUNCTION zzglc.data_aggregate_stability_r("Key" integer)
RETURNS TABLE(id integer, app_version character varying, aggregate_stability_index double precision, data_observation__observation_id integer, catalog_aggregate_stability_app__aggregate_stability_app_id integer, data_observation__observation_id_val character varying, catalog_aggregate_stability_app__aggregate_stability_app_id_val character varying)
LANGUAGE plpgsql
AS $function$
BEGIN
RETURN QUERY (
SELECT t.id, t.app_version, t.aggregate_stability_index, t.observation_id, t.aggregate_stability_app_id, observation_id.comment, aggregate_stability_app_id.name
FROM data.aggregate_stability t
LEFT JOIN data.observation observation_id ON observation_id.id = t.observation_id
LEFT JOIN catalog.aggregate_stability_app aggregate_stability_app_id ON aggregate_stability_app_id.id = t.aggregate_stability_app_id
WHERE t.observation_id = "Key"
ORDER BY 2
);
END $function$
*/
}
/**
* @function data_aggregate_stability_r_overload
* @overload data_aggregate_stability_r
* @memberof zzglc
* @description Data aggregate stability r
* @returns {Object} integer idcharacter_varying app_versiondouble_precision aggregate_stability_indexinteger data_observation__observation_idinteger catalog_aggregate_stability_app__aggregate_stability_app_idcharacter_varying data_observation__observation_id_valcharacter_varying catalog_aggregate_stability_app__aggregate_stability_app_id_val
*/
function data_aggregate_stability_r_overload() {
/*
CREATE OR REPLACE FUNCTION zzglc.data_aggregate_stability_r()
RETURNS TABLE(id integer, app_version character varying, aggregate_stability_index double precision, data_observation__observation_id integer, catalog_aggregate_stability_app__aggregate_stability_app_id integer, data_observation__observation_id_val character varying, catalog_aggregate_stability_app__aggregate_stability_app_id_val character varying)
LANGUAGE plpgsql
AS $function$
BEGIN
RETURN QUERY (
SELECT t.id, t.app_version, t.aggregate_stability_index, t.observation_id, t.aggregate_stability_app_id, observation_id.comment, aggregate_stability_app_id.name
FROM data.aggregate_stability t
LEFT JOIN data.observation observation_id ON observation_id.id = t.observation_id
LEFT JOIN catalog.aggregate_stability_app aggregate_stability_app_id ON aggregate_stability_app_id.id = t.aggregate_stability_app_id
ORDER BY 2
);
END $function$
*/
}
/**
* @function data_aggregate_stability_u
* @memberof zzglc
* @description Data aggregate stability u
* @param {character_varying} Json
* @returns {integer}
*/
function data_aggregate_stability_u() {
/*
CREATE OR REPLACE FUNCTION zzglc.data_aggregate_stability_u("Json" character varying)
RETURNS integer
LANGUAGE plpgsql
AS $function$
DECLARE v_id integer;
DECLARE json_data json;
BEGIN
json_data := "Json";
v_id := (json_data->>'id')::integer;
UPDATE data.aggregate_stability SET
app_version = (json_data->>'app_version')::character varying,
aggregate_stability_index = (json_data->>'aggregate_stability_index')::double precision,
observation_id = (json_data->>'observation_id')::integer,
aggregate_stability_app_id = (json_data->>'aggregate_stability_app_id')::integer
WHERE id = v_id;
RETURN v_id;
END $function$
*/
}
/**
* @function data_asset_c
* @memberof zzglc
* @description Data asset c
* @param {character_varying} Json
* @returns {integer}
*/
function data_asset_c() {
/*
CREATE OR REPLACE FUNCTION zzglc.data_asset_c("Json" character varying)
RETURNS integer
LANGUAGE plpgsql
AS $function$
DECLARE v_id integer;
DECLARE json_data json;
BEGIN
json_data := "Json";
INSERT INTO data.asset (orig_id, ignore, asset_catalog_id, title, description, asset_theme_id, keywords_list, asset_version_id, doi, unit_id, scale_factor, person_id, providers_list, license_id, constellation_list, platform, instruments_list, gsd, start_date, end_date, date_step, date_offset, date_unit_id, date_style_id, ignore_29feb, depth_list, main_sld_url, sld_1_url, main_qml_url, main_url, color_map, no_data, decimals, indicator_id, synonyms)
VALUES ((json_data->>'orig_id')::character varying, (json_data->>'ignore')::boolean, (json_data->>'asset_catalog_id')::integer, (json_data->>'title')::character varying, (json_data->>'description')::character varying, (json_data->>'asset_theme_id')::integer, (json_data->>'keywords_list')::character varying, (json_data->>'asset_version_id')::integer, (json_data->>'doi')::character varying, (json_data->>'unit_id')::integer, (json_data->>'scale_factor')::character varying, (json_data->>'person_id')::integer, (json_data->>'providers_list')::character varying, (json_data->>'license_id')::integer, (json_data->>'constellation_list')::character varying, (json_data->>'platform')::character varying, (json_data->>'instruments_list')::character varying, (json_data->>'gsd')::character varying, (json_data->>'start_date')::date, (json_data->>'end_date')::date, (json_data->>'date_step')::integer, (json_data->>'date_offset')::character varying, (json_data->>'date_unit_id')::integer, (json_data->>'date_style_id')::integer, (json_data->>'ignore_29feb')::boolean, (json_data->>'depth_list')::character varying, (json_data->>'main_sld_url')::character varying, (json_data->>'sld_1_url')::character varying, (json_data->>'main_qml_url')::character varying, (json_data->>'main_url')::character varying, (json_data->>'color_map')::character varying, (json_data->>'no_data')::integer, (json_data->>'decimals')::integer, (json_data->>'indicator_id')::integer, (json_data->>'synonyms')::character varying)
RETURNING id INTO v_id;
RETURN v_id;
END $function$
*/
}
/**
* @function data_asset_d
* @memberof zzglc
* @description Data asset d
* @param {integer} Key
* @returns {void}
*/
function data_asset_d() {
/*
CREATE OR REPLACE FUNCTION zzglc.data_asset_d("Key" integer)
RETURNS void
LANGUAGE plpgsql
AS $function$
BEGIN
DELETE FROM data.asset WHERE id = "Key";
END;
$function$
*/
}
/**
* @function data_asset_r
* @memberof zzglc
* @description Data asset r
* @returns {Object} integer idcharacter_varying orig_idboolean ignoreinteger catalog_asset_catalog__asset_catalog_idcharacter_varying titlecharacter_varying synonymscharacter_varying descriptioninteger catalog_asset_theme__asset_theme_idcharacter_varying keywords_listinteger catalog_asset_version__asset_version_idcharacter_varying doiinteger catalog_unit__unit_idcharacter_varying scale_factorinteger auth_person__person_idcharacter_varying providers_listinteger catalog_license__license_idcharacter_varying constellation_listcharacter_varying platformcharacter_varying instruments_listcharacter_varying gsddate start_datedate end_dateinteger date_stepcharacter_varying date_offsetinteger catalog_date_unit__date_unit_idinteger catalog_date_style__date_style_idboolean ignore_29febcharacter_varying depth_listcharacter_varying main_sld_urlcharacter_varying sld_1_urlcharacter_varying main_qml_urlcharacter_varying main_urlcharacter_varying color_mapinteger no_datainteger decimalsinteger data_indicator__indicator_idcharacter_varying catalog_asset_catalog__asset_catalog_id_valcharacter_varying catalog_asset_theme__asset_theme_id_valcharacter_varying catalog_asset_version__asset_version_id_valcharacter_varying catalog_unit__unit_id_valcharacter_varying auth_person__person_id_valcharacter_varying catalog_license__license_id_valcharacter_varying catalog_date_unit__date_unit_id_valcharacter_varying catalog_date_style__date_style_id_valcharacter_varying data_indicator__indicator_id_val
*/
function data_asset_r() {
/*
CREATE OR REPLACE FUNCTION zzglc.data_asset_r()
RETURNS TABLE(id integer, orig_id character varying, ignore boolean, catalog_asset_catalog__asset_catalog_id integer, title character varying, synonyms character varying, description character varying, catalog_asset_theme__asset_theme_id integer, keywords_list character varying, catalog_asset_version__asset_version_id integer, doi character varying, catalog_unit__unit_id integer, scale_factor character varying, auth_person__person_id integer, providers_list character varying, catalog_license__license_id integer, constellation_list character varying, platform character varying, instruments_list character varying, gsd character varying, start_date date, end_date date, date_step integer, date_offset character varying, catalog_date_unit__date_unit_id integer, catalog_date_style__date_style_id integer, ignore_29feb boolean, depth_list character varying, main_sld_url character varying, sld_1_url character varying, main_qml_url character varying, main_url character varying, color_map character varying, no_data integer, decimals integer, data_indicator__indicator_id integer, catalog_asset_catalog__asset_catalog_id_val character varying, catalog_asset_theme__asset_theme_id_val character varying, catalog_asset_version__asset_version_id_val character varying, catalog_unit__unit_id_val character varying, auth_person__person_id_val character varying, catalog_license__license_id_val character varying, catalog_date_unit__date_unit_id_val character varying, catalog_date_style__date_style_id_val character varying, data_indicator__indicator_id_val character varying)
LANGUAGE plpgsql
AS $function$
BEGIN
RETURN QUERY (
SELECT t.id, t.orig_id, t.ignore, t.asset_catalog_id, t.title, t.synonyms, t.description, t.asset_theme_id, t.keywords_list, t.asset_version_id, t.doi, t.unit_id, t.scale_factor, t.person_id, t.providers_list, t.license_id, t.constellation_list, t.platform, t.instruments_list, t.gsd, t.start_date, t.end_date, t.date_step, t.date_offset, t.date_unit_id, t.date_style_id, t.ignore_29feb, t.depth_list, t.main_sld_url, t.sld_1_url, t.main_qml_url, t.main_url, t.color_map, t.no_data, t.decimals, t.indicator_id, asset_catalog_id.name, asset_theme_id.name, asset_version_id.name, unit_id.name, person_id.name, license_id.name, date_unit_id.name, date_style_id.name, indicator_id.name
FROM data.asset t
LEFT JOIN catalog.asset_catalog asset_catalog_id ON asset_catalog_id.id = t.asset_catalog_id
LEFT JOIN catalog.asset_theme asset_theme_id ON asset_theme_id.id = t.asset_theme_id
LEFT JOIN catalog.asset_version asset_version_id ON asset_version_id.id = t.asset_version_id
LEFT JOIN catalog.unit unit_id ON unit_id.id = t.unit_id
LEFT JOIN auth.person person_id ON person_id.id = t.person_id
LEFT JOIN catalog.license license_id ON license_id.id = t.license_id
LEFT JOIN catalog.date_unit date_unit_id ON date_unit_id.id = t.date_unit_id
LEFT JOIN catalog.date_style date_style_id ON date_style_id.id = t.date_style_id
LEFT JOIN data.indicator indicator_id ON indicator_id.id = t.indicator_id
ORDER BY 2
);
END $function$
*/
}
/**
* @function data_asset_theme_c
* @memberof zzglc
* @description Data asset theme c
* @param {character_varying} Json
* @returns {void}
*/
function data_asset_theme_c() {
/*
CREATE OR REPLACE FUNCTION zzglc.data_asset_theme_c("Json" character varying)
RETURNS void
LANGUAGE plpgsql
AS $function$
BEGIN
INSERT INTO data.asset_theme (
name
)
SELECT
U.name
FROM
json_to_record("Json"::json) U (
name character varying
)
;
END $function$
*/
}
/**
* @function data_asset_theme_d
* @memberof zzglc
* @description Data asset theme d
* @param {integer} Key
* @returns {void}
*/
function data_asset_theme_d() {
/*
CREATE OR REPLACE FUNCTION zzglc.data_asset_theme_d("Key" integer)
RETURNS void
LANGUAGE plpgsql
AS $function$
BEGIN
DELETE FROM data.asset_theme
WHERE id = "Key";
END $function$
*/
}
/**
* @function data_asset_theme_r
* @memberof zzglc
* @description Data asset theme r
* @returns {Object}
* @property {integer} id
* @property {character_varying} name
*/
function data_asset_theme_r() {
/*
CREATE OR REPLACE FUNCTION zzglc.data_asset_theme_r()
RETURNS TABLE(id integer, name character varying)
LANGUAGE plpgsql
AS $function$
BEGIN
RETURN QUERY
SELECT
t.id, t.name
FROM data.asset_theme t
;
END $function$
*/
}
/**
* @function data_asset_theme_u
* @memberof zzglc
* @description Data asset theme u
* @param {character_varying} Json
* @returns {void}
*/
function data_asset_theme_u() {
/*
CREATE OR REPLACE FUNCTION zzglc.data_asset_theme_u("Json" character varying)
RETURNS void
LANGUAGE plpgsql
AS $function$
DECLARE v_row_count INTEGER;
BEGIN
UPDATE data.asset_theme t
SET name = U.name
FROM json_to_record("Json"::json) AS U (
id integer,
name character varying
)
WHERE U.id = t.id
;
END $function$
*/
}
/**
* @function data_asset_u
* @memberof zzglc
* @description Data asset u
* @param {character_varying} Json
* @returns {void}
*/
function data_asset_u() {
/*
CREATE OR REPLACE FUNCTION zzglc.data_asset_u("Json" character varying)
RETURNS void
LANGUAGE plpgsql
AS $function$
DECLARE json_data json;
BEGIN
json_data := "Json";
UPDATE data.asset SET
orig_id = (json_data->>'orig_id')::character varying,
ignore = (json_data->>'ignore')::boolean,
asset_catalog_id = (json_data->>'asset_catalog_id')::integer,
title = (json_data->>'title')::character varying,
description = (json_data->>'description')::character varying,
asset_theme_id = (json_data->>'asset_theme_id')::integer,
keywords_list = (json_data->>'keywords_list')::character varying,
asset_version_id = (json_data->>'asset_version_id')::integer,
doi = (json_data->>'doi')::character varying,
unit_id = (json_data->>'unit_id')::integer,
scale_factor = (json_data->>'scale_factor')::character varying,
person_id = (json_data->>'person_id')::integer,
providers_list = (json_data->>'providers_list')::character varying,
license_id = (json_data->>'license_id')::integer,
constellation_list = (json_data->>'constellation_list')::character varying,
platform = (json_data->>'platform')::character varying,
instruments_list = (json_data->>'instruments_list')::character varying,
gsd = (json_data->>'gsd')::character varying,
start_date = (json_data->>'start_date')::date,
end_date = (json_data->>'end_date')::date,
date_step = (json_data->>'date_step')::integer,
date_offset = (json_data->>'date_offset')::character varying,
date_unit_id = (json_data->>'date_unit_id')::integer,
date_style_id = (json_data->>'date_style_id')::integer,
ignore_29feb = (json_data->>'ignore_29feb')::boolean,
depth_list = (json_data->>'depth_list')::character varying,
main_sld_url = (json_data->>'main_sld_url')::character varying,
sld_1_url = (json_data->>'sld_1_url')::character varying,
main_qml_url = (json_data->>'main_qml_url')::character varying,
main_url = (json_data->>'main_url')::character varying,
color_map = (json_data->>'color_map')::character varying,
no_data = (json_data->>'no_data')::integer,
decimals = (json_data->>'decimals')::integer,
indicator_id = (json_data->>'indicator_id')::integer,
synonyms = (json_data->>'synonyms')::character varying
WHERE id = (json_data->>'id')::integer;
END $function$
*/
}
/**
* @function data_attribute_c
* @memberof zzglc
* @description Data attribute c
* @param {character_varying} Json
* @returns {integer}
*/
function data_attribute_c() {
/*
CREATE OR REPLACE FUNCTION zzglc.data_attribute_c("Json" character varying)
RETURNS integer
LANGUAGE plpgsql
AS $function$
DECLARE v_id integer;
DECLARE json_data json;
BEGIN
json_data := "Json";
INSERT INTO data.attribute (point_id, indicator_id, data_source_id, date, attribute_description_id, depth_id)
VALUES ((json_data->>'point_id')::integer, (json_data->>'indicator_id')::integer, (json_data->>'data_source_id')::integer, (json_data->>'date')::date, (json_data->>'attribute_description_id')::integer, (json_data->>'depth_id')::integer)
RETURNING id INTO v_id;
RETURN v_id;
END $function$
*/
}
/**
* @function data_attribute_d
* @memberof zzglc
* @description Data attribute d
* @param {integer} Key
* @returns {void}
*/
function data_attribute_d() {
/*
CREATE OR REPLACE FUNCTION zzglc.data_attribute_d("Key" integer)
RETURNS void
LANGUAGE plpgsql
AS $function$
BEGIN
DELETE FROM data.attribute WHERE id = "Key";
END;
$function$
*/
}
/**
* @function data_attribute_description_c
* @memberof zzglc
* @description Data attribute description c
* @param {character_varying} Json
* @returns {integer}
*/
function data_attribute_description_c() {
/*
CREATE OR REPLACE FUNCTION zzglc.data_attribute_description_c("Json" character varying)
RETURNS integer
LANGUAGE plpgsql
AS $function$
DECLARE v_id integer;
DECLARE json_data json;
BEGIN
json_data := "Json";
INSERT INTO data.attribute_description (indicator_id, name, color_id, code, value)
VALUES ((json_data->>'indicator_id')::integer, (json_data->>'name')::character varying, (json_data->>'color_id')::integer, (json_data->>'code')::character varying, (json_data->>'value')::integer)
RETURNING id INTO v_id;
RETURN v_id;
END $function$
*/
}
/**
* @function data_attribute_description_d
* @memberof zzglc
* @description Data attribute description d
* @param {integer} Key
* @returns {void}
*/
function data_attribute_description_d() {
/*
CREATE OR REPLACE FUNCTION zzglc.data_attribute_description_d("Key" integer)
RETURNS void
LANGUAGE plpgsql
AS $function$
BEGIN
DELETE FROM data.attribute_description WHERE id = "Key";
END;
$function$
*/
}
/**
* @function data_attribute_description_d_overload
* @overload data_attribute_description_d
* @memberof zzglc
* @description Data attribute description d
* @param {integer[]} Keys
* @returns {void}
*/
function data_attribute_description_d_overload() {
/*
CREATE OR REPLACE FUNCTION zzglc.data_attribute_description_d("Keys" integer[])
RETURNS void
LANGUAGE plpgsql
AS $function$
BEGIN
DROP TABLE IF EXISTS ids;
CREATE TEMP TABLE ids AS
SELECT unnest("Keys"::int[]) AS id;
DELETE FROM data.attribute_description
USING ids WHERE ids.id = data.attribute_description.id;
RETURN;
END $function$
*/
}
/**
* @function data_attribute_description_r
* @memberof zzglc
* @description Data attribute description r
* @returns {Object} integer idinteger data_indicator__indicator_idcharacter_varying nameinteger general_color__color_idcharacter_varying codeinteger valuecharacter_varying data_indicator__indicator_id_valtext general_color__color_id_val
*/
function data_attribute_description_r() {
/*
CREATE OR REPLACE FUNCTION zzglc.data_attribute_description_r()
RETURNS TABLE(id integer, data_indicator__indicator_id integer, name character varying, general_color__color_id integer, code character varying, value integer, data_indicator__indicator_id_val character varying, general_color__color_id_val text)
LANGUAGE plpgsql
AS $function$
BEGIN
RETURN QUERY (
SELECT t.id, t.indicator_id, t.name, t.color_id, t.code, t.value, indicator_id.display_name, '<span class="c-b" style="background-color:' || color_id.code || '"></span>' || color_id.name
FROM data.attribute_description t
LEFT JOIN data.indicator indicator_id ON indicator_id.id = t.indicator_id
LEFT JOIN general.color color_id ON color_id.id = t.color_id
ORDER BY 2
);
END $function$
*/
}
/**
* @function data_attribute_description_u
* @memberof zzglc
* @description Data attribute description u
* @param {character_varying} Json
* @returns {integer}
*/
function data_attribute_description_u() {
/*
CREATE OR REPLACE FUNCTION zzglc.data_attribute_description_u("Json" character varying)
RETURNS integer
LANGUAGE plpgsql
AS $function$
DECLARE v_id integer;
DECLARE json_data json;
BEGIN
json_data := "Json";
v_id := (json_data->>'id')::integer;
UPDATE data.attribute_description SET
indicator_id = (json_data->>'indicator_id')::integer,
name = (json_data->>'name')::character varying,
color_id = (json_data->>'color_id')::integer,
code = (json_data->>'code')::character varying,
value = (json_data->>'value')::integer
WHERE id = v_id;
RETURN v_id;
END $function$
*/
}
/**
* @function data_attribute_r
* @memberof zzglc
* @description Data attribute r
* @returns {Object} integer idinteger data_point__point_idinteger indicator_idinteger data_data_source__data_source_iddate dateinteger attribute_description_idinteger depth_idcharacter_varying data_point__point_id_valcharacter_varying indicator_id_valcharacter_varying data_data_source__data_source_id_valcharacter_varying attribute_description_id_valcharacter_varying depth_id_val
*/
function data_attribute_r() {
/*
CREATE OR REPLACE FUNCTION zzglc.data_attribute_r()
RETURNS TABLE(id integer, data_point__point_id integer, indicator_id integer, data_data_source__data_source_id integer, date date, attribute_description_id integer, depth_id integer, data_point__point_id_val character varying, indicator_id_val character varying, data_data_source__data_source_id_val character varying, attribute_description_id_val character varying, depth_id_val character varying)
LANGUAGE plpgsql
AS $function$
BEGIN
RETURN QUERY (
SELECT t.id, t.point_id, t.indicator_id, t.data_source_id, t.date, t.attribute_description_id, t.depth_id, point_id.point_key, indicator_id.name, data_source_id.name, attribute_description_id.name, depth_id.name
FROM data.attribute t
LEFT JOIN data.point point_id ON point_id.id = t.point_id
LEFT JOIN data.indicator indicator_id ON indicator_id.id = t.indicator_id
LEFT JOIN data.data_source data_source_id ON data_source_id.id = t.data_source_id
LEFT JOIN data.attribute_description attribute_description_id ON attribute_description_id.id = t.attribute_description_id
LEFT JOIN data.depth depth_id ON depth_id.id = t.depth_id
);
END $function$
*/
}
/**
* @function data_attribute_u
* @memberof zzglc
* @description Data attribute u
* @param {character_varying} Json
* @returns {void}
*/
function data_attribute_u() {
/*
CREATE OR REPLACE FUNCTION zzglc.data_attribute_u("Json" character varying)
RETURNS void
LANGUAGE plpgsql
AS $function$
DECLARE json_data json;
BEGIN
json_data := "Json";
UPDATE data.attribute SET
point_id = (json_data->>'point_id')::integer,
indicator_id = (json_data->>'indicator_id')::integer,
data_source_id = (json_data->>'data_source_id')::integer,
date = (json_data->>'date')::date,
attribute_description_id = (json_data->>'attribute_description_id')::integer,
depth_id = (json_data->>'depth_id')::integer
WHERE id = (json_data->>'id')::integer;
END $function$
*/
}
/**
* @function data_bioinformatic_treatment_c
* @memberof zzglc
* @description Data bioinformatic treatment c
* @param {character_varying} Json
* @returns {integer}
*/
function data_bioinformatic_treatment_c() {
/*
CREATE OR REPLACE FUNCTION zzglc.data_bioinformatic_treatment_c("Json" character varying)
RETURNS integer
LANGUAGE plpgsql
AS $function$
DECLARE v_id integer;
DECLARE json_data json;
BEGIN
json_data := "Json";
INSERT INTO data.bioinformatic_treatment (name, url)
VALUES ((json_data->>'name')::character varying, (json_data->>'url')::character varying)
RETURNING id INTO v_id;
RETURN v_id;
END $function$
*/
}
/**
* @function data_bioinformatic_treatment_d
* @memberof zzglc
* @description Data bioinformatic treatment d
* @param {integer} Key
* @returns {void}
*/
function data_bioinformatic_treatment_d() {
/*
CREATE OR REPLACE FUNCTION zzglc.data_bioinformatic_treatment_d("Key" integer)
RETURNS void
LANGUAGE plpgsql
AS $function$
BEGIN
DELETE FROM data.bioinformatic_treatment WHERE id = "Key";
END;
$function$
*/
}
/**
* @function data_bioinformatic_treatment_r
* @memberof zzglc
* @description Data bioinformatic treatment r
* @returns {Object} integer idcharacter_varying namecharacter_varying url
*/
function data_bioinformatic_treatment_r() {
/*
CREATE OR REPLACE FUNCTION zzglc.data_bioinformatic_treatment_r()
RETURNS TABLE(id integer, name character varying, url character varying)
LANGUAGE plpgsql
AS $function$
BEGIN
RETURN QUERY (
SELECT t.id, t.name, t.url
FROM data.bioinformatic_treatment t
ORDER BY 2
);
END $function$
*/
}
/**
* @function data_bioinformatic_treatment_u
* @memberof zzglc
* @description Data bioinformatic treatment u
* @param {character_varying} Json
* @returns {integer}
*/
function data_bioinformatic_treatment_u() {
/*
CREATE OR REPLACE FUNCTION zzglc.data_bioinformatic_treatment_u("Json" character varying)
RETURNS integer
LANGUAGE plpgsql
AS $function$
DECLARE v_id integer;
DECLARE json_data json;
BEGIN
json_data := "Json";
v_id := (json_data->>'id')::integer;
UPDATE data.bioinformatic_treatment SET
name = (json_data->>'name')::character varying,
url = (json_data->>'url')::character varying
WHERE id = v_id;
RETURN v_id;
END $function$
*/
}
/**
* @function data_cultivation_c
* @memberof zzglc
* @description Data cultivation c
* @param {character_varying} Json
* @returns {integer}
*/
function data_cultivation_c() {
/*
CREATE OR REPLACE FUNCTION zzglc.data_cultivation_c("Json" character varying)
RETURNS integer
LANGUAGE plpgsql
AS $function$
DECLARE v_id integer;
DECLARE json_data json;
BEGIN
json_data := "Json";
INSERT INTO data.cultivation (point_id, cultivation_year, cultivation_season_start_date, cultivation_season_end_date, baresoil_over_whole_season, tillage, irrigation_mm, manure_fertilisation_kg_ha, chemical_fertilisation_kg_ha, pesticides_kg_ha, main_crop_id, catch_crop_id, main_yield_kg_ha, catch_yield_kg_ha, person_id, start_date, end_date, perennial_crop)
VALUES ((json_data->>'point_id')::integer, (json_data->>'cultivation_year')::smallint, (json_data->>'cultivation_season_start_date')::date, (json_data->>'cultivation_season_end_date')::date, (json_data->>'baresoil_over_whole_season')::boolean, (json_data->>'tillage')::boolean, (json_data->>'irrigation_mm')::smallint, (json_data->>'manure_fertilisation_kg_ha')::smallint, (json_data->>'chemical_fertilisation_kg_ha')::smallint, (json_data->>'pesticides_kg_ha')::smallint, (json_data->>'main_crop_id')::integer, (json_data->>'catch_crop_id')::integer, (json_data->>'main_yield_kg_ha')::smallint, (json_data->>'catch_yield_kg_ha')::smallint, auth.get_context_person_id(), (json_data->>'start_date')::date, (json_data->>'end_date')::date, (json_data->>'perennial_crop')::boolean)
RETURNING id INTO v_id;
RETURN v_id;
END $function$
*/
}
/**
* @function data_cultivation_d
* @memberof zzglc
* @description Data cultivation d
* @param {integer} Key
* @returns {void}
*/
function data_cultivation_d() {
/*
CREATE OR REPLACE FUNCTION zzglc.data_cultivation_d("Key" integer)
RETURNS void
LANGUAGE plpgsql
AS $function$
BEGIN
DELETE FROM data.cultivation WHERE id = "Key";
END;
$function$
*/
}
/**
* @function data_cultivation_r
* @memberof zzglc
* @description Data cultivation r
* @param {integer} Key
* @returns {Object} integer idinteger data_point__point_idsmallint cultivation_yeardate cultivation_season_start_datedate cultivation_season_end_dateboolean baresoil_over_whole_seasonboolean tillagesmallint irrigation_mmsmallint manure_fertilisation_kg_hasmallint chemical_fertilisation_kg_hasmallint pesticides_kg_hainteger catalog_crop__main_crop_idinteger catalog_crop__catch_crop_idsmallint main_yield_kg_hasmallint catch_yield_kg_hainteger auth_person__person_iddate start_datedate end_dateboolean perennial_cropcharacter_varying data_point__point_id_valcharacter_varying catalog_crop__main_crop_id_valcharacter_varying catalog_crop__catch_crop_id_valcharacter_varying auth_person__person_id_val
*/
function data_cultivation_r() {
/*
CREATE OR REPLACE FUNCTION zzglc.data_cultivation_r("Key" integer)
RETURNS TABLE(id integer, data_point__point_id integer, cultivation_year smallint, cultivation_season_start_date date, cultivation_season_end_date date, baresoil_over_whole_season boolean, tillage boolean, irrigation_mm smallint, manure_fertilisation_kg_ha smallint, chemical_fertilisation_kg_ha smallint, pesticides_kg_ha smallint, catalog_crop__main_crop_id integer, catalog_crop__catch_crop_id integer, main_yield_kg_ha smallint, catch_yield_kg_ha smallint, auth_person__person_id integer, start_date date, end_date date, perennial_crop boolean, data_point__point_id_val character varying, catalog_crop__main_crop_id_val character varying, catalog_crop__catch_crop_id_val character varying, auth_person__person_id_val character varying)
LANGUAGE plpgsql
AS $function$
BEGIN
RETURN QUERY (
SELECT t.id, t.point_id, t.cultivation_year, t.cultivation_season_start_date, t.cultivation_season_end_date, t.baresoil_over_whole_season, t.tillage, t.irrigation_mm, t.manure_fertilisation_kg_ha, t.chemical_fertilisation_kg_ha, t.pesticides_kg_ha, t.main_crop_id, t.catch_crop_id, t.main_yield_kg_ha, t.catch_yield_kg_ha, t.person_id, t.start_date, t.end_date, t.perennial_crop, point_id.point_key, main_crop_id.name, catch_crop_id.name, person_id.email
FROM data.cultivation t
LEFT JOIN auth.vw_partner vwp ON vwp.user_id = t.person_id AND vwp.partner_user_id = auth.get_context_person_id()
LEFT JOIN data.point point_id ON point_id.id = t.point_id
LEFT JOIN catalog.crop main_crop_id ON main_crop_id.id = t.main_crop_id
LEFT JOIN catalog.crop catch_crop_id ON catch_crop_id.id = t.catch_crop_id
LEFT JOIN auth.person person_id ON person_id.id = t.person_id
WHERE t.point_id = "Key"
ORDER BY 2
);
END $function$
*/
}
/**
* @function data_cultivation_r_overload
* @overload data_cultivation_r
* @memberof zzglc
* @description Data cultivation r
* @returns {Object} integer idinteger data_point__point_idsmallint cultivation_yeardate cultivation_season_start_datedate cultivation_season_end_dateboolean baresoil_over_whole_seasonboolean tillagesmallint irrigation_mmsmallint manure_fertilisation_kg_hasmallint chemical_fertilisation_kg_hasmallint pesticides_kg_hainteger catalog_crop__main_crop_idinteger catalog_crop__catch_crop_idsmallint main_yield_kg_hasmallint catch_yield_kg_hainteger auth_person__person_iddate start_datedate end_dateboolean perennial_cropcharacter_varying data_point__point_id_valcharacter_varying catalog_crop__main_crop_id_valcharacter_varying catalog_crop__catch_crop_id_valcharacter_varying auth_person__person_id_val
*/
function data_cultivation_r_overload() {
/*
CREATE OR REPLACE FUNCTION zzglc.data_cultivation_r()
RETURNS TABLE(id integer, data_point__point_id integer, cultivation_year smallint, cultivation_season_start_date date, cultivation_season_end_date date, baresoil_over_whole_season boolean, tillage boolean, irrigation_mm smallint, manure_fertilisation_kg_ha smallint, chemical_fertilisation_kg_ha smallint, pesticides_kg_ha smallint, catalog_crop__main_crop_id integer, catalog_crop__catch_crop_id integer, main_yield_kg_ha smallint, catch_yield_kg_ha smallint, auth_person__person_id integer, start_date date, end_date date, perennial_crop boolean, data_point__point_id_val character varying, catalog_crop__main_crop_id_val character varying, catalog_crop__catch_crop_id_val character varying, auth_person__person_id_val character varying)
LANGUAGE plpgsql
AS $function$
BEGIN
RETURN QUERY (
SELECT t.id, t.point_id, t.cultivation_year, t.cultivation_season_start_date, t.cultivation_season_end_date, t.baresoil_over_whole_season, t.tillage, t.irrigation_mm, t.manure_fertilisation_kg_ha, t.chemical_fertilisation_kg_ha, t.pesticides_kg_ha, t.main_crop_id, t.catch_crop_id, t.main_yield_kg_ha, t.catch_yield_kg_ha, t.person_id, t.start_date, t.end_date, t.perennial_crop, point_id.point_key, main_crop_id.name, catch_crop_id.name, person_id.email
FROM data.cultivation t
LEFT JOIN auth.vw_partner vwp ON vwp.user_id = t.person_id AND vwp.partner_user_id = auth.get_context_person_id()
LEFT JOIN data.point point_id ON point_id.id = t.point_id
LEFT JOIN catalog.crop main_crop_id ON main_crop_id.id = t.main_crop_id
LEFT JOIN catalog.crop catch_crop_id ON catch_crop_id.id = t.catch_crop_id
LEFT JOIN auth.person person_id ON person_id.id = t.person_id
WHERE vwp.user_id = auth.get_context_person_id() OR auth.get_context_is_admin()
ORDER BY 2
);
END $function$
*/
}
/**
* @function data_cultivation_u
* @memberof zzglc
* @description Data cultivation u
* @param {character_varying} Json
* @returns {integer}
*/
function data_cultivation_u() {
/*
CREATE OR REPLACE FUNCTION zzglc.data_cultivation_u("Json" character varying)
RETURNS integer
LANGUAGE plpgsql
AS $function$
DECLARE v_id integer;
DECLARE json_data json;
BEGIN
json_data := "Json";
v_id := (json_data->>'id')::integer;
UPDATE data.cultivation SET
point_id = (json_data->>'point_id')::integer,
cultivation_year = (json_data->>'cultivation_year')::smallint,
cultivation_season_start_date = (json_data->>'cultivation_season_start_date')::date,
cultivation_season_end_date = (json_data->>'cultivation_season_end_date')::date,
baresoil_over_whole_season = (json_data->>'baresoil_over_whole_season')::boolean,
tillage = (json_data->>'tillage')::boolean,
irrigation_mm = (json_data->>'irrigation_mm')::smallint,
manure_fertilisation_kg_ha = (json_data->>'manure_fertilisation_kg_ha')::smallint,
chemical_fertilisation_kg_ha = (json_data->>'chemical_fertilisation_kg_ha')::smallint,
pesticides_kg_ha = (json_data->>'pesticides_kg_ha')::smallint,
main_crop_id = (json_data->>'main_crop_id')::integer,
catch_crop_id = (json_data->>'catch_crop_id')::integer,
main_yield_kg_ha = (json_data->>'main_yield_kg_ha')::smallint,
catch_yield_kg_ha = (json_data->>'catch_yield_kg_ha')::smallint,
person_id = (json_data->>'person_id')::integer,
start_date = (json_data->>'start_date')::date,
end_date = (json_data->>'end_date')::date,
perennial_crop = (json_data->>'perennial_crop')::boolean
WHERE id = v_id;
RETURN v_id;
END $function$
*/
}
/**
* @function data_custom_geometry_c
* @memberof zzglc
* @description Data custom geometry c
* @param {character_varying} Json
* @returns {integer}
*/
function data_custom_geometry_c() {
/*
CREATE OR REPLACE FUNCTION zzglc.data_custom_geometry_c("Json" character varying)
RETURNS integer
LANGUAGE plpgsql
AS $function$
DECLARE v_id integer;
DECLARE json_data json;
BEGIN
json_data := "Json";
INSERT INTO data.custom_geometry (person_id, name, public, time_modified, time_created)
VALUES ((json_data->>'person_id')::integer, (json_data->>'name')::character varying, (json_data->>'public')::boolean, (json_data->>'time_modified')::timestamp with time zone, (json_data->>'time_created')::timestamp with time zone)
RETURNING id INTO v_id;
RETURN v_id;
END $function$
*/
}
/**
* @function data_custom_geometry_d
* @memberof zzglc
* @description Data custom geometry d
* @param {integer} Key
* @returns {void}
*/
function data_custom_geometry_d() {
/*
CREATE OR REPLACE FUNCTION zzglc.data_custom_geometry_d("Key" integer)
RETURNS void
LANGUAGE plpgsql
AS $function$
BEGIN
DELETE FROM data.custom_geometry WHERE id = "Key";
END;
$function$
*/
}
/**
* @function data_custom_geometry_file_c
* @memberof zzglc
* @description Data custom geometry file c
* @param {character_varying} Json
* @returns {integer}
*/
function data_custom_geometry_file_c() {
/*
CREATE OR REPLACE FUNCTION zzglc.data_custom_geometry_file_c("Json" character varying)
RETURNS integer
LANGUAGE plpgsql
AS $function$
DECLARE v_id integer;
DECLARE json_data json;
BEGIN
json_data := "Json";
INSERT INTO data.custom_geometry_file (custom_geometry_id, name, extension, mime_type, compass, lat, lon, time_created, time_modified, pitch)
VALUES ((json_data->>'custom_geometry_id')::integer, (json_data->>'name')::character varying, (json_data->>'extension')::character varying, (json_data->>'mime_type')::character varying, (json_data->>'compass')::integer, (json_data->>'lat')::double precision, (json_data->>'lon')::double precision, (json_data->>'time_created')::timestamp with time zone, (json_data->>'time_modified')::timestamp with time zone, (json_data->>'pitch')::integer)
RETURNING id INTO v_id;
RETURN v_id;
END $function$
*/
}
/**
* @function data_custom_geometry_file_d
* @memberof zzglc
* @description Data custom geometry file d
* @param {integer} Key
* @returns {void}
*/
function data_custom_geometry_file_d() {
/*
CREATE OR REPLACE FUNCTION zzglc.data_custom_geometry_file_d("Key" integer)
RETURNS void
LANGUAGE plpgsql
AS $function$
BEGIN
DELETE FROM data.custom_geometry_file WHERE id = "Key";
END;
$function$
*/
}
/**
* @function data_custom_geometry_file_r
* @memberof zzglc
* @description Data custom geometry file r
* @returns {Object} integer idinteger data_custom_geometry__custom_geometry_idcharacter_varying namecharacter_varying extensioncharacter_varying mime_typeinteger compassdouble_precision latdouble_precision lontimestamp_with_time_zone time_createdtimestamp_with_time_zone time_modifiedinteger pitchcharacter_varying data_custom_geometry__custom_geometry_id_val
*/
function data_custom_geometry_file_r() {
/*
CREATE OR REPLACE FUNCTION zzglc.data_custom_geometry_file_r()
RETURNS TABLE(id integer, data_custom_geometry__custom_geometry_id integer, name character varying, extension character varying, mime_type character varying, compass integer, lat double precision, lon double precision, time_created timestamp with time zone, time_modified timestamp with time zone, pitch integer, data_custom_geometry__custom_geometry_id_val character varying)
LANGUAGE plpgsql
AS $function$
BEGIN
RETURN QUERY (
SELECT t.id, t.custom_geometry_id, t.name, t.extension, t.mime_type, t.compass, t.lat, t.lon, t.time_created, t.time_modified, t.pitch, custom_geometry_id.name
FROM data.custom_geometry_file t
LEFT JOIN data.custom_geometry custom_geometry_id ON custom_geometry_id.id = t.custom_geometry_id
ORDER BY 2
);
END $function$
*/
}
/**
* @function data_custom_geometry_file_u
* @memberof zzglc
* @description Data custom geometry file u
* @param {character_varying} Json
* @returns {integer}
*/
function data_custom_geometry_file_u() {
/*
CREATE OR REPLACE FUNCTION zzglc.data_custom_geometry_file_u("Json" character varying)
RETURNS integer
LANGUAGE plpgsql
AS $function$
DECLARE v_id integer;
DECLARE json_data json;
BEGIN
json_data := "Json";
v_id := (json_data->>'id')::integer;
UPDATE data.custom_geometry_file SET
custom_geometry_id = (json_data->>'custom_geometry_id')::integer,
name = (json_data->>'name')::character varying,
extension = (json_data->>'extension')::character varying,
mime_type = (json_data->>'mime_type')::character varying,
compass = (json_data->>'compass')::integer,
lat = (json_data->>'lat')::double precision,
lon = (json_data->>'lon')::double precision,
time_created = (json_data->>'time_created')::timestamp with time zone,
time_modified = (json_data->>'time_modified')::timestamp with time zone,
pitch = (json_data->>'pitch')::integer
WHERE id = v_id;
RETURN v_id;
END $function$
*/
}
/**
* @function data_custom_geometry_property_c
* @memberof zzglc
* @description Data custom geometry property c
* @param {character_varying} Json
* @returns {integer}
*/
function data_custom_geometry_property_c() {
/*
CREATE OR REPLACE FUNCTION zzglc.data_custom_geometry_property_c("Json" character varying)
RETURNS integer
LANGUAGE plpgsql
AS $function$
DECLARE v_id integer;
DECLARE json_data json;
BEGIN
json_data := "Json";
INSERT INTO data.custom_geometry_property (custom_geometry_time_id, property_id, value)
VALUES ((json_data->>'custom_geometry_time_id')::integer, (json_data->>'property_id')::integer, (json_data->>'value')::character varying)
RETURNING id INTO v_id;
RETURN v_id;
END $function$
*/
}
/**
* @function data_custom_geometry_property_d
* @memberof zzglc
* @description Data custom geometry property d
* @param {integer} Key
* @returns {void}
*/
function data_custom_geometry_property_d() {
/*
CREATE OR REPLACE FUNCTION zzglc.data_custom_geometry_property_d("Key" integer)
RETURNS void
LANGUAGE plpgsql
AS $function$
BEGIN
DELETE FROM data.custom_geometry_property WHERE id = "Key";
END;
$function$
*/
}
/**
* @function data_custom_geometry_property_r
* @memberof zzglc
* @description Data custom geometry property r
* @returns {Object} integer idinteger data_custom_geometry_time__custom_geometry_time_idinteger data_property__property_idcharacter_varying valuecharacter_varying data_custom_geometry_time__custom_geometry_time_id_valcharacter_varying data_property__property_id_val
*/
function data_custom_geometry_property_r() {
/*
CREATE OR REPLACE FUNCTION zzglc.data_custom_geometry_property_r()
RETURNS TABLE(id integer, data_custom_geometry_time__custom_geometry_time_id integer, data_property__property_id integer, value character varying, data_custom_geometry_time__custom_geometry_time_id_val character varying, data_property__property_id_val character varying)
LANGUAGE plpgsql
AS $function$
BEGIN
RETURN QUERY (
SELECT t.id, t.custom_geometry_time_id, t.property_id, t.value, custom_geometry_time_id.id::varchar, property_id.name
FROM data.custom_geometry_property t
LEFT JOIN data.custom_geometry_time custom_geometry_time_id ON custom_geometry_time_id.id = t.custom_geometry_time_id
LEFT JOIN data.property property_id ON property_id.id = t.property_id
ORDER BY 2
);
END $function$
*/
}
/**
* @function data_custom_geometry_property_u
* @memberof zzglc
* @description Data custom geometry property u
* @param {character_varying} Json
* @returns {integer}
*/
function data_custom_geometry_property_u() {
/*
CREATE OR REPLACE FUNCTION zzglc.data_custom_geometry_property_u("Json" character varying)
RETURNS integer
LANGUAGE plpgsql
AS $function$
DECLARE v_id integer;
DECLARE json_data json;
BEGIN
json_data := "Json";
v_id := (json_data->>'id')::integer;
UPDATE data.custom_geometry_property SET
custom_geometry_time_id = (json_data->>'custom_geometry_time_id')::integer,
property_id = (json_data->>'property_id')::integer,
value = (json_data->>'value')::character varying
WHERE id = v_id;
RETURN v_id;
END $function$
*/
}
/**
* @function data_custom_geometry_r
* @memberof zzglc
* @description Data custom geometry r
* @returns {Object} integer idinteger auth_person__person_idcharacter_varying nameboolean publictimestamp_with_time_zone time_modifiedtimestamp_with_time_zone time_createdcharacter_varying auth_person__person_id_val
*/
function data_custom_geometry_r() {
/*
CREATE OR REPLACE FUNCTION zzglc.data_custom_geometry_r()
RETURNS TABLE(id integer, auth_person__person_id integer, name character varying, public boolean, time_modified timestamp with time zone, time_created timestamp with time zone, auth_person__person_id_val character varying)
LANGUAGE plpgsql
AS $function$
BEGIN
RETURN QUERY (
SELECT t.id, t.person_id, t.name, t.public, t.time_modified, t.time_created, person_id.email
FROM data.custom_geometry t
LEFT JOIN auth.person person_id ON person_id.id = t.person_id
ORDER BY 2
);
END $function$
*/
}
/**
* @function data_custom_geometry_time_c
* @memberof zzglc
* @description Data custom geometry time c
* @param {character_varying} Json
* @returns {integer}
*/
function data_custom_geometry_time_c() {
/*
CREATE OR REPLACE FUNCTION zzglc.data_custom_geometry_time_c("Json" character varying)
RETURNS integer
LANGUAGE plpgsql
AS $function$
DECLARE v_id integer;
DECLARE json_data json;
BEGIN
json_data := "Json";
INSERT INTO data.custom_geometry_time (custom_geometry_id, observation_time)
VALUES ((json_data->>'custom_geometry_id')::integer, (json_data->>'observation_time')::timestamp with time zone)
RETURNING id INTO v_id;
RETURN v_id;
END $function$
*/
}
/**
* @function data_custom_geometry_time_d
* @memberof zzglc
* @description Data custom geometry time d
* @param {integer} Key
* @returns {void}
*/
function data_custom_geometry_time_d() {
/*
CREATE OR REPLACE FUNCTION zzglc.data_custom_geometry_time_d("Key" integer)
RETURNS void
LANGUAGE plpgsql
AS $function$
BEGIN
DELETE FROM data.custom_geometry_time WHERE id = "Key";
END;
$function$
*/
}
/**
* @function data_custom_geometry_time_r
* @memberof zzglc
* @description Data custom geometry time r
* @returns {Object} integer idinteger data_custom_geometry__custom_geometry_idtimestamp_with_time_zone observation_timecharacter_varying data_custom_geometry__custom_geometry_id_val
*/
function data_custom_geometry_time_r() {
/*
CREATE OR REPLACE FUNCTION zzglc.data_custom_geometry_time_r()
RETURNS TABLE(id integer, data_custom_geometry__custom_geometry_id integer, observation_time timestamp with time zone, data_custom_geometry__custom_geometry_id_val character varying)
LANGUAGE plpgsql
AS $function$
BEGIN
RETURN QUERY (
SELECT t.id, t.custom_geometry_id, t.observation_time, custom_geometry_id.name
FROM data.custom_geometry_time t
LEFT JOIN data.custom_geometry custom_geometry_id ON custom_geometry_id.id = t.custom_geometry_id
ORDER BY 2
);
END $function$
*/
}
/**
* @function data_custom_geometry_time_u
* @memberof zzglc
* @description Data custom geometry time u
* @param {character_varying} Json
* @returns {integer}
*/
function data_custom_geometry_time_u() {
/*
CREATE OR REPLACE FUNCTION zzglc.data_custom_geometry_time_u("Json" character varying)
RETURNS integer
LANGUAGE plpgsql
AS $function$
DECLARE v_id integer;
DECLARE json_data json;
BEGIN
json_data := "Json";
v_id := (json_data->>'id')::integer;
UPDATE data.custom_geometry_time SET
custom_geometry_id = (json_data->>'custom_geometry_id')::integer,
observation_time = (json_data->>'observation_time')::timestamp with time zone
WHERE id = v_id;
RETURN v_id;
END $function$
*/
}
/**
* @function data_custom_geometry_u
* @memberof zzglc
* @description Data custom geometry u
* @param {character_varying} Json
* @returns {integer}
*/
function data_custom_geometry_u() {
/*
CREATE OR REPLACE FUNCTION zzglc.data_custom_geometry_u("Json" character varying)
RETURNS integer
LANGUAGE plpgsql
AS $function$
DECLARE v_id integer;
DECLARE json_data json;
BEGIN
json_data := "Json";
v_id := (json_data->>'id')::integer;
UPDATE data.custom_geometry SET
person_id = (json_data->>'person_id')::integer,
name = (json_data->>'name')::character varying,
public = (json_data->>'public')::boolean,
time_modified = (json_data->>'time_modified')::timestamp with time zone,
time_created = (json_data->>'time_created')::timestamp with time zone
WHERE id = v_id;
RETURN v_id;
END $function$
*/
}
/**
* @function data_data_source_c
* @memberof zzglc
* @description Data data source c
* @param {character_varying} Json
* @returns {integer}
*/
function data_data_source_c() {
/*
CREATE OR REPLACE FUNCTION zzglc.data_data_source_c("Json" character varying)
RETURNS integer
LANGUAGE plpgsql
AS $function$
DECLARE v_id integer;
DECLARE json_data json;
BEGIN
json_data := "Json";
INSERT INTO data.data_source (name, srid, public, country_id, contact_person_id, person_id, description, url, ai4soilhealth_pilot, date_from, date_to)
VALUES ((json_data->>'name')::character varying, (json_data->>'srid')::integer, (json_data->>'public')::boolean, (json_data->>'country_id')::integer, (json_data->>'contact_person_id')::integer, (json_data->>'person_id')::integer, (json_data->>'description')::text, (json_data->>'url')::character varying, (json_data->>'ai4soilhealth_pilot')::boolean, (json_data->>'date_from')::date, (json_data->>'date_to')::date)
RETURNING id INTO v_id;
RETURN v_id;
END $function$
*/
}
/**
* @function data_data_source_d
* @memberof zzglc
* @description Data data source d
* @param {integer} Key
* @returns {void}
*/
function data_data_source_d() {
/*
CREATE OR REPLACE FUNCTION zzglc.data_data_source_d("Key" integer)
RETURNS void
LANGUAGE plpgsql
AS $function$
BEGIN
DELETE FROM data.data_source WHERE id = "Key";
END;
$function$
*/
}
/**
* @function data_data_source_r
* @memberof zzglc
* @description Data data source r
* @returns {Object} integer idcharacter_varying nameinteger sridboolean publicinteger general_country__country_idinteger auth_person__contact_person_idinteger auth_person__person_idtext descriptioncharacter_varying urlboolean ai4soilhealth_pilotdate date_fromdate date_tocharacter_varying general_country__country_id_valcharacter_varying auth_person__contact_person_id_valcharacter_varying auth_person__person_id_val
*/
function data_data_source_r() {
/*
CREATE OR REPLACE FUNCTION zzglc.data_data_source_r()
RETURNS TABLE(id integer, name character varying, srid integer, public boolean, general_country__country_id integer, auth_person__contact_person_id integer, auth_person__person_id integer, description text, url character varying, ai4soilhealth_pilot boolean, date_from date, date_to date, general_country__country_id_val character varying, auth_person__contact_person_id_val character varying, auth_person__person_id_val character varying)
LANGUAGE plpgsql
AS $function$
BEGIN
RETURN QUERY (
SELECT t.id, t.name, t.srid, t.public, t.country_id, t.contact_person_id, t.person_id, t.description, t.url, t.ai4soilhealth_pilot, t.date_from, t.date_to, country_id.name, contact_person_id.email, person_id.email
FROM data.data_source t
LEFT JOIN general.country country_id ON country_id.id = t.country_id
LEFT JOIN auth.person contact_person_id ON contact_person_id.id = t.contact_person_id
LEFT JOIN auth.person person_id ON person_id.id = t.person_id
ORDER BY 2
);
END $function$
*/
}
/**
* @function data_data_source_u
* @memberof zzglc
* @description Data data source u
* @param {character_varying} Json
* @returns {integer}
*/
function data_data_source_u() {
/*
CREATE OR REPLACE FUNCTION zzglc.data_data_source_u("Json" character varying)
RETURNS integer
LANGUAGE plpgsql
AS $function$
DECLARE v_id integer;
DECLARE json_data json;
BEGIN
json_data := "Json";
v_id := (json_data->>'id')::integer;
UPDATE data.data_source SET
name = (json_data->>'name')::character varying,
srid = (json_data->>'srid')::integer,
public = (json_data->>'public')::boolean,
country_id = (json_data->>'country_id')::integer,
contact_person_id = (json_data->>'contact_person_id')::integer,
person_id = (json_data->>'person_id')::integer,
description = (json_data->>'description')::text,
url = (json_data->>'url')::character varying,
ai4soilhealth_pilot = (json_data->>'ai4soilhealth_pilot')::boolean,
date_from = (json_data->>'date_from')::date,
date_to = (json_data->>'date_to')::date
WHERE id = v_id;
RETURN v_id;
END $function$
*/
}
/**
* @function data_date_style_c
* @memberof zzglc
* @description Data date style c
* @param {character_varying} Json
* @returns {void}
*/
function data_date_style_c() {
/*
CREATE OR REPLACE FUNCTION zzglc.data_date_style_c("Json" character varying)
RETURNS void
LANGUAGE plpgsql
AS $function$
BEGIN
INSERT INTO data.date_style (
name
)
SELECT
U.name
FROM
json_to_record("Json"::json) U (
name character varying
)
;
END $function$
*/
}
/**
* @function data_date_style_d
* @memberof zzglc
* @description Data date style d
* @param {integer} Key
* @returns {void}
*/
function data_date_style_d() {
/*
CREATE OR REPLACE FUNCTION zzglc.data_date_style_d("Key" integer)
RETURNS void
LANGUAGE plpgsql
AS $function$
BEGIN
DELETE FROM data.date_style
WHERE id = "Key";
END $function$
*/
}
/**
* @function data_date_style_r
* @memberof zzglc
* @description Data date style r
* @returns {Object}
* @property {integer} id
* @property {character_varying} name
*/
function data_date_style_r() {
/*
CREATE OR REPLACE FUNCTION zzglc.data_date_style_r()
RETURNS TABLE(id integer, name character varying)
LANGUAGE plpgsql
AS $function$
BEGIN
RETURN QUERY
SELECT
t.id, t.name
FROM data.date_style t
;
END $function$
*/
}
/**
* @function data_date_style_u
* @memberof zzglc
* @description Data date style u
* @param {character_varying} Json
* @returns {void}
*/
function data_date_style_u() {
/*
CREATE OR REPLACE FUNCTION zzglc.data_date_style_u("Json" character varying)
RETURNS void
LANGUAGE plpgsql
AS $function$
DECLARE v_row_count INTEGER;
BEGIN
UPDATE data.date_style t
SET name = U.name
FROM json_to_record("Json"::json) AS U (
id integer,
name character varying
)
WHERE U.id = t.id
;
END $function$
*/
}
/**
* @function data_date_unit_c
* @memberof zzglc
* @description Data date unit c
* @param {character_varying} Json
* @returns {void}
*/
function data_date_unit_c() {
/*
CREATE OR REPLACE FUNCTION zzglc.data_date_unit_c("Json" character varying)
RETURNS void
LANGUAGE plpgsql
AS $function$
BEGIN
INSERT INTO data.date_unit (
name,
format
)
SELECT
U.name,
U.format
FROM
json_to_record("Json"::json) U (
name character varying,
format character varying
)
;
END $function$
*/
}
/**
* @function data_date_unit_d
* @memberof zzglc
* @description Data date unit d
* @param {integer} Key
* @returns {void}
*/
function data_date_unit_d() {
/*
CREATE OR REPLACE FUNCTION zzglc.data_date_unit_d("Key" integer)
RETURNS void
LANGUAGE plpgsql
AS $function$
BEGIN
DELETE FROM data.date_unit
WHERE id = "Key";
END $function$
*/
}
/**
* @function data_date_unit_r
* @memberof zzglc
* @description Data date unit r
* @returns {Object}
* @property {integer} id
* @property {character_varying} name
* @property {character_varying} format
*/
function data_date_unit_r() {
/*
CREATE OR REPLACE FUNCTION zzglc.data_date_unit_r()
RETURNS TABLE(id integer, name character varying, format character varying)
LANGUAGE plpgsql
AS $function$
BEGIN
RETURN QUERY
SELECT
t.id, t.name, t.format
FROM data.date_unit t
;
END $function$
*/
}
/**
* @function data_date_unit_u
* @memberof zzglc
* @description Data date unit u
* @param {character_varying} Json
* @returns {void}
*/
function data_date_unit_u() {
/*
CREATE OR REPLACE FUNCTION zzglc.data_date_unit_u("Json" character varying)
RETURNS void
LANGUAGE plpgsql
AS $function$
DECLARE v_row_count INTEGER;
BEGIN
UPDATE data.date_unit t
SET name = U.name,
format = U.format
FROM json_to_record("Json"::json) AS U (
id integer,
name character varying,
format character varying
)
WHERE U.id = t.id
;
END $function$
*/
}
/**
* @function data_depth_c
* @memberof zzglc
* @description Data depth c
* @param {character_varying} Json
* @returns {void}
*/
function data_depth_c() {
/*
CREATE OR REPLACE FUNCTION zzglc.data_depth_c("Json" character varying)
RETURNS void
LANGUAGE plpgsql
AS $function$
BEGIN
INSERT INTO data.depth (
name,
color_id
)
SELECT
U.name,
U.color_id
FROM
json_to_record("Json"::json) U (
name character varying,
color_id integer
)
;
END $function$
*/
}
/**
* @function data_depth_d
* @memberof zzglc
* @description Data depth d
* @param {integer} Key
* @returns {void}
*/
function data_depth_d() {
/*
CREATE OR REPLACE FUNCTION zzglc.data_depth_d("Key" integer)
RETURNS void
LANGUAGE plpgsql
AS $function$
BEGIN
DELETE FROM data.depth
WHERE id = "Key";
END $function$
*/
}
/**
* @function data_depth_r
* @memberof zzglc
* @description Data depth r
* @returns {Object}
* @property {integer} id
* @property {character_varying} name
* @property {integer} color_id
* @property {character_varying} color_id_val
* @property {character_varying} color_code
*/
function data_depth_r() {
/*
CREATE OR REPLACE FUNCTION zzglc.data_depth_r()
RETURNS TABLE(id integer, name character varying, general_color__color_id integer, general_color__color_id_val character varying, color_code character varying)
LANGUAGE plpgsql
AS $function$
BEGIN
RETURN QUERY
SELECT
t.id, t.name, t.color_id
, color_id_t.name::VARCHAR AS color_id_val
, color_id_t.code
FROM data.depth t
LEFT JOIN general.color color_id_t ON color_id_t.id = t.color_id
ORDER BY t.name
;
END
$function$
*/
}
/**
* @function data_depth_u
* @memberof zzglc
* @description Data depth u
* @param {character_varying} Json
* @returns {void}
*/
function data_depth_u() {
/*
CREATE OR REPLACE FUNCTION zzglc.data_depth_u("Json" character varying)
RETURNS void
LANGUAGE plpgsql
AS $function$
DECLARE v_row_count INTEGER;
BEGIN
UPDATE data.depth t
SET name = U.name,
color_id = U.color_id
FROM json_to_record("Json"::json) AS U (
id integer,
name character varying,
color_id integer
)
WHERE U.id = t.id
;
END $function$
*/
}
/**
* @function data_edna_c
* @memberof zzglc
* @description Data edna c
* @param {character_varying} Json
* @returns {integer}
*/
function data_edna_c() {
/*
CREATE OR REPLACE FUNCTION zzglc.data_edna_c("Json" character varying)
RETURNS integer
LANGUAGE plpgsql
AS $function$
DECLARE v_id integer;
DECLARE json_data json;
BEGIN
json_data := "Json";
INSERT INTO data.edna (nucleotide_archive_id, observation_id, accession_code, accession_url, extraction_id, amplification_id, purification_id, sequencing_id)
VALUES ((json_data->>'nucleotide_archive_id')::integer, (json_data->>'observation_id')::integer, (json_data->>'accession_code')::character varying, (json_data->>'accession_url')::character varying, (json_data->>'extraction_id')::integer, (json_data->>'amplification_id')::integer, (json_data->>'purification_id')::integer, (json_data->>'sequencing_id')::integer)
RETURNING id INTO v_id;
RETURN v_id;
END $function$
*/
}
/**
* @function data_edna_d
* @memberof zzglc
* @description Data edna d
* @param {integer} Key
* @returns {void}
*/
function data_edna_d() {
/*
CREATE OR REPLACE FUNCTION zzglc.data_edna_d("Key" integer)
RETURNS void
LANGUAGE plpgsql
AS $function$
BEGIN
DELETE FROM data.edna WHERE id = "Key";
END;
$function$
*/
}
/**
* @function data_edna_r
* @memberof zzglc
* @description Data edna r
* @param {integer} Key
* @returns {Object} integer idinteger data_nucleotide_archive__nucleotide_archive_idinteger data_observation__observation_idcharacter_varying accession_codecharacter_varying accession_urlinteger catalog_extraction__extraction_idinteger catalog_amplification__amplification_idinteger catalog_purification__purification_idinteger catalog_sequencing__sequencing_idcharacter_varying data_nucleotide_archive__nucleotide_archive_id_valcharacter_varying data_observation__observation_id_valcharacter_varying catalog_extraction__extraction_id_valcharacter_varying catalog_amplification__amplification_id_valcharacter_varying catalog_purification__purification_id_valcharacter_varying catalog_sequencing__sequencing_id_val
*/
function data_edna_r() {
/*
CREATE OR REPLACE FUNCTION zzglc.data_edna_r("Key" integer)
RETURNS TABLE(id integer, data_nucleotide_archive__nucleotide_archive_id integer, data_observation__observation_id integer, accession_code character varying, accession_url character varying, catalog_extraction__extraction_id integer, catalog_amplification__amplification_id integer, catalog_purification__purification_id integer, catalog_sequencing__sequencing_id integer, data_nucleotide_archive__nucleotide_archive_id_val character varying, data_observation__observation_id_val character varying, catalog_extraction__extraction_id_val character varying, catalog_amplification__amplification_id_val character varying, catalog_purification__purification_id_val character varying, catalog_sequencing__sequencing_id_val character varying)
LANGUAGE plpgsql
AS $function$
BEGIN
RETURN QUERY (
SELECT t.id, t.nucleotide_archive_id, t.observation_id, t.accession_code, t.accession_url, t.extraction_id, t.amplification_id, t.purification_id, t.sequencing_id, nucleotide_archive_id.database_name, observation_id.comment, extraction_id.name, amplification_id.name, purification_id.name, sequencing_id.name
FROM data.edna t
LEFT JOIN data.nucleotide_archive nucleotide_archive_id ON nucleotide_archive_id.id = t.nucleotide_archive_id
LEFT JOIN data.observation observation_id ON observation_id.id = t.observation_id
LEFT JOIN catalog.extraction extraction_id ON extraction_id.id = t.extraction_id
LEFT JOIN catalog.amplification amplification_id ON amplification_id.id = t.amplification_id
LEFT JOIN catalog.purification purification_id ON purification_id.id = t.purification_id
LEFT JOIN catalog.sequencing sequencing_id ON sequencing_id.id = t.sequencing_id
WHERE t.observation_id = "Key"
ORDER BY 2
);
END $function$
*/
}
/**
* @function data_edna_r_overload
* @overload data_edna_r
* @memberof zzglc
* @description Data edna r
* @returns {Object} integer idinteger data_nucleotide_archive__nucleotide_archive_idinteger data_observation__observation_idcharacter_varying accession_codecharacter_varying accession_urlinteger catalog_extraction__extraction_idinteger catalog_amplification__amplification_idinteger catalog_purification__purification_idinteger catalog_sequencing__sequencing_idcharacter_varying data_nucleotide_archive__nucleotide_archive_id_valcharacter_varying data_observation__observation_id_valcharacter_varying catalog_extraction__extraction_id_valcharacter_varying catalog_amplification__amplification_id_valcharacter_varying catalog_purification__purification_id_valcharacter_varying catalog_sequencing__sequencing_id_val
*/
function data_edna_r_overload() {
/*
CREATE OR REPLACE FUNCTION zzglc.data_edna_r()
RETURNS TABLE(id integer, data_nucleotide_archive__nucleotide_archive_id integer, data_observation__observation_id integer, accession_code character varying, accession_url character varying, catalog_extraction__extraction_id integer, catalog_amplification__amplification_id integer, catalog_purification__purification_id integer, catalog_sequencing__sequencing_id integer, data_nucleotide_archive__nucleotide_archive_id_val character varying, data_observation__observation_id_val character varying, catalog_extraction__extraction_id_val character varying, catalog_amplification__amplification_id_val character varying, catalog_purification__purification_id_val character varying, catalog_sequencing__sequencing_id_val character varying)
LANGUAGE plpgsql
AS $function$
BEGIN
RETURN QUERY (
SELECT t.id, t.nucleotide_archive_id, t.observation_id, t.accession_code, t.accession_url, t.extraction_id, t.amplification_id, t.purification_id, t.sequencing_id, nucleotide_archive_id.database_name, observation_id.comment, extraction_id.name, amplification_id.name, purification_id.name, sequencing_id.name
FROM data.edna t
LEFT JOIN data.nucleotide_archive nucleotide_archive_id ON nucleotide_archive_id.id = t.nucleotide_archive_id
LEFT JOIN data.observation observation_id ON observation_id.id = t.observation_id
LEFT JOIN catalog.extraction extraction_id ON extraction_id.id = t.extraction_id
LEFT JOIN catalog.amplification amplification_id ON amplification_id.id = t.amplification_id
LEFT JOIN catalog.purification purification_id ON purification_id.id = t.purification_id
LEFT JOIN catalog.sequencing sequencing_id ON sequencing_id.id = t.sequencing_id
ORDER BY 2
);
END $function$
*/
}
/**
* @function data_edna_u
* @memberof zzglc
* @description Data edna u
* @param {character_varying} Json
* @returns {integer}
*/
function data_edna_u() {
/*
CREATE OR REPLACE FUNCTION zzglc.data_edna_u("Json" character varying)
RETURNS integer
LANGUAGE plpgsql
AS $function$
DECLARE v_id integer;
DECLARE json_data json;
BEGIN
json_data := "Json";
v_id := (json_data->>'id')::integer;
UPDATE data.edna SET
nucleotide_archive_id = (json_data->>'nucleotide_archive_id')::integer,
observation_id = (json_data->>'observation_id')::integer,
accession_code = (json_data->>'accession_code')::character varying,
accession_url = (json_data->>'accession_url')::character varying,
extraction_id = (json_data->>'extraction_id')::integer,
amplification_id = (json_data->>'amplification_id')::integer,
purification_id = (json_data->>'purification_id')::integer,
sequencing_id = (json_data->>'sequencing_id')::integer
WHERE id = v_id;
RETURN v_id;
END $function$
*/
}
/**
* @function data_enzyme_c
* @memberof zzglc
* @description Data enzyme c
* @param {character_varying} Json
* @returns {integer}
*/
function data_enzyme_c() {
/*
CREATE OR REPLACE FUNCTION zzglc.data_enzyme_c("Json" character varying)
RETURNS integer
LANGUAGE plpgsql
AS $function$
DECLARE v_id integer;
DECLARE json_data json;
BEGIN
json_data := "Json";
INSERT INTO data.enzyme (temperature, observation_id)
VALUES ((json_data->>'temperature')::double precision, (json_data->>'observation_id')::integer)
RETURNING id INTO v_id;
RETURN v_id;
END $function$
*/
}
/**
* @function data_enzyme_d
* @memberof zzglc
* @description Data enzyme d
* @param {integer} Key
* @returns {void}
*/
function data_enzyme_d() {
/*
CREATE OR REPLACE FUNCTION zzglc.data_enzyme_d("Key" integer)
RETURNS void
LANGUAGE plpgsql
AS $function$
BEGIN
DELETE FROM data.enzyme WHERE id = "Key";
END;
$function$
*/
}
/**
* @function data_enzyme_item_c
* @memberof zzglc
* @description Data enzyme item c
* @param {character_varying} Json
* @returns {integer}
*/
function data_enzyme_item_c() {
/*
CREATE OR REPLACE FUNCTION zzglc.data_enzyme_item_c("Json" character varying)
RETURNS integer
LANGUAGE plpgsql
AS $function$
DECLARE v_id integer;
DECLARE json_data json;
BEGIN
json_data := "Json";
INSERT INTO data.enzyme_item (enzyme_type_id, pmol_min, std_err, is_valid, not_valid_reason, enzyme_id)
VALUES ((json_data->>'enzyme_type_id')::integer, (json_data->>'pmol_min')::double precision, (json_data->>'std_err')::double precision, (json_data->>'is_valid')::boolean, (json_data->>'not_valid_reason')::character varying, (json_data->>'enzyme_id')::integer)
RETURNING id INTO v_id;
RETURN v_id;
END $function$
*/
}
/**
* @function data_enzyme_item_d
* @memberof zzglc
* @description Data enzyme item d
* @param {integer} Key
* @returns {void}
*/
function data_enzyme_item_d() {
/*
CREATE OR REPLACE FUNCTION zzglc.data_enzyme_item_d("Key" integer)
RETURNS void
LANGUAGE plpgsql
AS $function$
BEGIN
DELETE FROM data.enzyme_item WHERE id = "Key";
END;
$function$
*/
}
/**
* @function data_enzyme_item_r
* @memberof zzglc
* @description Data enzyme item r
* @param {integer} Key
* @returns {Object} integer idinteger catalog_enzyme_type__enzyme_type_iddouble_precision pmol_mindouble_precision std_errboolean is_validcharacter_varying not_valid_reasoninteger data_enzyme__enzyme_idcharacter_varying catalog_enzyme_type__enzyme_type_id_valcharacter_varying data_enzyme__enzyme_id_val
*/
function data_enzyme_item_r() {
/*
CREATE OR REPLACE FUNCTION zzglc.data_enzyme_item_r("Key" integer)
RETURNS TABLE(id integer, catalog_enzyme_type__enzyme_type_id integer, pmol_min double precision, std_err double precision, is_valid boolean, not_valid_reason character varying, data_enzyme__enzyme_id integer, catalog_enzyme_type__enzyme_type_id_val character varying, data_enzyme__enzyme_id_val character varying)
LANGUAGE plpgsql
AS $function$
BEGIN
RETURN QUERY (
SELECT t.id, t.enzyme_type_id, t.pmol_min, t.std_err, t.is_valid, t.not_valid_reason, t.enzyme_id, enzyme_type_id.name, enzyme_id.observation_id::varchar
FROM data.enzyme_item t
LEFT JOIN catalog.enzyme_type enzyme_type_id ON enzyme_type_id.id = t.enzyme_type_id
LEFT JOIN data.enzyme enzyme_id ON enzyme_id.id = t.enzyme_id
WHERE t.enzyme_id = "Key"
ORDER BY 2
);
END $function$
*/
}
/**
* @function data_enzyme_item_r_overload
* @overload data_enzyme_item_r
* @memberof zzglc
* @description Data enzyme item r
* @returns {Object} integer idinteger catalog_enzyme_type__enzyme_type_iddouble_precision pmol_mindouble_precision std_errboolean is_validcharacter_varying not_valid_reasoninteger data_enzyme__enzyme_idcharacter_varying catalog_enzyme_type__enzyme_type_id_valcharacter_varying data_enzyme__enzyme_id_val
*/
function data_enzyme_item_r_overload() {
/*
CREATE OR REPLACE FUNCTION zzglc.data_enzyme_item_r()
RETURNS TABLE(id integer, catalog_enzyme_type__enzyme_type_id integer, pmol_min double precision, std_err double precision, is_valid boolean, not_valid_reason character varying, data_enzyme__enzyme_id integer, catalog_enzyme_type__enzyme_type_id_val character varying, data_enzyme__enzyme_id_val character varying)
LANGUAGE plpgsql
AS $function$
BEGIN
RETURN QUERY (
SELECT t.id, t.enzyme_type_id, t.pmol_min, t.std_err, t.is_valid, t.not_valid_reason, t.enzyme_id, enzyme_type_id.name, enzyme_id.observation_id::varchar
FROM data.enzyme_item t
LEFT JOIN catalog.enzyme_type enzyme_type_id ON enzyme_type_id.id = t.enzyme_type_id
LEFT JOIN data.enzyme enzyme_id ON enzyme_id.id = t.enzyme_id
ORDER BY 2
);
END $function$
*/
}
/**
* @function data_enzyme_item_u
* @memberof zzglc
* @description Data enzyme item u
* @param {character_varying} Json
* @returns {integer}
*/
function data_enzyme_item_u() {
/*
CREATE OR REPLACE FUNCTION zzglc.data_enzyme_item_u("Json" character varying)
RETURNS integer
LANGUAGE plpgsql
AS $function$
DECLARE v_id integer;
DECLARE json_data json;
BEGIN
json_data := "Json";
v_id := (json_data->>'id')::integer;
UPDATE data.enzyme_item SET
enzyme_type_id = (json_data->>'enzyme_type_id')::integer,
pmol_min = (json_data->>'pmol_min')::double precision,
std_err = (json_data->>'std_err')::double precision,
is_valid = (json_data->>'is_valid')::boolean,
not_valid_reason = (json_data->>'not_valid_reason')::character varying,
enzyme_id = (json_data->>'enzyme_id')::integer
WHERE id = v_id;
RETURN v_id;
END $function$
*/
}
/**
* @function data_enzyme_r
* @memberof zzglc
* @description Data enzyme r
* @param {integer} Key
* @returns {Object} integer iddouble_precision temperatureinteger data_observation__observation_idcharacter_varying data_observation__observation_id_val
*/
function data_enzyme_r() {
/*
CREATE OR REPLACE FUNCTION zzglc.data_enzyme_r("Key" integer)
RETURNS TABLE(id integer, temperature double precision, data_observation__observation_id integer, data_observation__observation_id_val character varying)
LANGUAGE plpgsql
AS $function$
BEGIN
RETURN QUERY (
SELECT t.id, t.temperature, t.observation_id, observation_id.comment
FROM data.enzyme t
LEFT JOIN data.observation observation_id ON observation_id.id = t.observation_id
WHERE t.observation_id = "Key"
ORDER BY 2
);
END $function$
*/
}
/**
* @function data_enzyme_r_overload
* @overload data_enzyme_r
* @memberof zzglc
* @description Data enzyme r
* @returns {Object} integer iddouble_precision temperatureinteger data_observation__observation_idcharacter_varying data_observation__observation_id_val
*/
function data_enzyme_r_overload() {
/*
CREATE OR REPLACE FUNCTION zzglc.data_enzyme_r()
RETURNS TABLE(id integer, temperature double precision, data_observation__observation_id integer, data_observation__observation_id_val character varying)
LANGUAGE plpgsql
AS $function$
BEGIN
RETURN QUERY (
SELECT t.id, t.temperature, t.observation_id, observation_id.comment
FROM data.enzyme t
LEFT JOIN data.observation observation_id ON observation_id.id = t.observation_id
ORDER BY 2
);
END $function$
*/
}
/**
* @function data_enzyme_u
* @memberof zzglc
* @description Data enzyme u
* @param {character_varying} Json
* @returns {integer}
*/
function data_enzyme_u() {
/*
CREATE OR REPLACE FUNCTION zzglc.data_enzyme_u("Json" character varying)
RETURNS integer
LANGUAGE plpgsql
AS $function$
DECLARE v_id integer;
DECLARE json_data json;
BEGIN
json_data := "Json";
v_id := (json_data->>'id')::integer;
UPDATE data.enzyme SET
temperature = (json_data->>'temperature')::double precision,
observation_id = (json_data->>'observation_id')::integer
WHERE id = v_id;
RETURN v_id;
END $function$
*/
}
/**
* @function data_equipment_c
* @memberof zzglc
* @description Data equipment c
* @param {character_varying} Json
* @returns {integer}
*/
function data_equipment_c() {
/*
CREATE OR REPLACE FUNCTION zzglc.data_equipment_c("Json" character varying)
RETURNS integer
LANGUAGE plpgsql
AS $function$
DECLARE v_id integer;
DECLARE json_data json;
BEGIN
json_data := "Json";
INSERT INTO data.equipment (brand_id, model, serial_number, equipment_type_id, person_id, nickname)
VALUES ((json_data->>'brand_id')::integer, (json_data->>'model')::character varying, (json_data->>'serial_number')::character varying, (json_data->>'equipment_type_id')::integer, (json_data->>'person_id')::integer, (json_data->>'nickname')::character varying)
RETURNING id INTO v_id;
RETURN v_id;
END $function$
*/
}
/**
* @function data_equipment_d
* @memberof zzglc
* @description Data equipment d
* @param {integer} Key
* @returns {void}
*/
function data_equipment_d() {
/*
CREATE OR REPLACE FUNCTION zzglc.data_equipment_d("Key" integer)
RETURNS void
LANGUAGE plpgsql
AS $function$
BEGIN
DELETE FROM data.equipment WHERE id = "Key";
END;
$function$
*/
}
/**
* @function data_equipment_indicator_c
* @memberof zzglc
* @description Data equipment indicator c
* @param {character_varying} Json
* @returns {integer}
*/
function data_equipment_indicator_c() {
/*
CREATE OR REPLACE FUNCTION zzglc.data_equipment_indicator_c("Json" character varying)
RETURNS integer
LANGUAGE plpgsql
AS $function$
DECLARE v_id integer;
DECLARE json_data json;
BEGIN
json_data := "Json";
INSERT INTO data.equipment_indicator (equipment_id, indicator_id, unit_id, gain, add)
VALUES ((json_data->>'equipment_id')::integer, (json_data->>'indicator_id')::integer, (json_data->>'unit_id')::integer, (json_data->>'gain')::double precision, (json_data->>'add')::double precision)
RETURNING id INTO v_id;
RETURN v_id;
END $function$
*/
}
/**
* @function data_equipment_indicator_d
* @memberof zzglc
* @description Data equipment indicator d
* @param {integer} Key
* @returns {void}
*/
function data_equipment_indicator_d() {
/*
CREATE OR REPLACE FUNCTION zzglc.data_equipment_indicator_d("Key" integer)
RETURNS void
LANGUAGE plpgsql
AS $function$
BEGIN
DELETE FROM data.equipment_indicator WHERE id = "Key";
END;
$function$
*/
}
/**
* @function data_equipment_indicator_r
* @memberof zzglc
* @description Data equipment indicator r
* @param {integer} Key
* @returns {Object} integer idinteger data_equipment__equipment_idinteger data_indicator__indicator_idinteger catalog_unit__unit_iddouble_precision gaindouble_precision addcharacter_varying data_equipment__equipment_id_valcharacter_varying data_indicator__indicator_id_valcharacter_varying catalog_unit__unit_id_val
*/
function data_equipment_indicator_r() {
/*
CREATE OR REPLACE FUNCTION zzglc.data_equipment_indicator_r("Key" integer)
RETURNS TABLE(id integer, data_equipment__equipment_id integer, data_indicator__indicator_id integer, catalog_unit__unit_id integer, gain double precision, add double precision, data_equipment__equipment_id_val character varying, data_indicator__indicator_id_val character varying, catalog_unit__unit_id_val character varying)
LANGUAGE plpgsql
AS $function$
BEGIN
RETURN QUERY (
SELECT t.id, t.equipment_id, t.indicator_id, t.unit_id, t.gain, t.add, equipment_id.model, indicator_id.name, unit_id.name
FROM data.equipment_indicator t
LEFT JOIN data.equipment equipment_id ON equipment_id.id = t.equipment_id
LEFT JOIN data.indicator indicator_id ON indicator_id.id = t.indicator_id
LEFT JOIN catalog.unit unit_id ON unit_id.id = t.unit_id
WHERE t.equipment_id = "Key"
ORDER BY 2
);
END $function$
*/
}
/**
* @function data_equipment_indicator_r_overload
* @overload data_equipment_indicator_r
* @memberof zzglc
* @description Data equipment indicator r
* @returns {Object} integer idinteger data_equipment__equipment_idinteger data_indicator__indicator_idinteger catalog_unit__unit_iddouble_precision gaindouble_precision addcharacter_varying data_equipment__equipment_id_valcharacter_varying data_indicator__indicator_id_valcharacter_varying catalog_unit__unit_id_val
*/
function data_equipment_indicator_r_overload() {
/*
CREATE OR REPLACE FUNCTION zzglc.data_equipment_indicator_r()
RETURNS TABLE(id integer, data_equipment__equipment_id integer, data_indicator__indicator_id integer, catalog_unit__unit_id integer, gain double precision, add double precision, data_equipment__equipment_id_val character varying, data_indicator__indicator_id_val character varying, catalog_unit__unit_id_val character varying)
LANGUAGE plpgsql
AS $function$
BEGIN
RETURN QUERY (
SELECT t.id, t.equipment_id, t.indicator_id, t.unit_id, t.gain, t.add, equipment_id.model, indicator_id.name, unit_id.name
FROM data.equipment_indicator t
LEFT JOIN data.equipment equipment_id ON equipment_id.id = t.equipment_id
LEFT JOIN data.indicator indicator_id ON indicator_id.id = t.indicator_id
LEFT JOIN catalog.unit unit_id ON unit_id.id = t.unit_id
ORDER BY 2
);
END $function$
*/
}
/**
* @function data_equipment_indicator_u
* @memberof zzglc
* @description Data equipment indicator u
* @param {character_varying} Json
* @returns {integer}
*/
function data_equipment_indicator_u() {
/*
CREATE OR REPLACE FUNCTION zzglc.data_equipment_indicator_u("Json" character varying)
RETURNS integer
LANGUAGE plpgsql
AS $function$
DECLARE v_id integer;
DECLARE json_data json;
BEGIN
json_data := "Json";
v_id := (json_data->>'id')::integer;
UPDATE data.equipment_indicator SET
equipment_id = (json_data->>'equipment_id')::integer,
indicator_id = (json_data->>'indicator_id')::integer,
unit_id = (json_data->>'unit_id')::integer,
gain = (json_data->>'gain')::double precision,
add = (json_data->>'add')::double precision
WHERE id = v_id;
RETURN v_id;
END $function$
*/
}
/**
* @function data_equipment_r
* @memberof zzglc
* @description Data equipment r
* @returns {Object} integer idinteger catalog_brand__brand_idcharacter_varying modelcharacter_varying serial_numberinteger catalog_equipment_type__equipment_type_idinteger auth_person__person_idcharacter_varying nicknamecharacter_varying catalog_brand__brand_id_valcharacter_varying catalog_equipment_type__equipment_type_id_valcharacter_varying auth_person__person_id_val
*/
function data_equipment_r() {
/*
CREATE OR REPLACE FUNCTION zzglc.data_equipment_r()
RETURNS TABLE(id integer, catalog_brand__brand_id integer, model character varying, serial_number character varying, catalog_equipment_type__equipment_type_id integer, auth_person__person_id integer, nickname character varying, catalog_brand__brand_id_val character varying, catalog_equipment_type__equipment_type_id_val character varying, auth_person__person_id_val character varying)
LANGUAGE plpgsql
AS $function$
BEGIN
RETURN QUERY (
SELECT t.id, t.brand_id, t.model, t.serial_number, t.equipment_type_id, t.person_id, t.nickname, brand_id.name, equipment_type_id.name, person_id.email
FROM data.equipment t
LEFT JOIN catalog.brand brand_id ON brand_id.id = t.brand_id
LEFT JOIN catalog.equipment_type equipment_type_id ON equipment_type_id.id = t.equipment_type_id
LEFT JOIN auth.person person_id ON person_id.id = t.person_id
ORDER BY equipment_type_id.name
);
END $function$
*/
}
/**
* @function data_equipment_u
* @memberof zzglc
* @description Data equipment u
* @param {character_varying} Json
* @returns {integer}
*/
function data_equipment_u() {
/*
CREATE OR REPLACE FUNCTION zzglc.data_equipment_u("Json" character varying)
RETURNS integer
LANGUAGE plpgsql
AS $function$
DECLARE v_id integer;
DECLARE json_data json;
BEGIN
json_data := "Json";
v_id := (json_data->>'id')::integer;
UPDATE data.equipment SET
brand_id = (json_data->>'brand_id')::integer,
model = (json_data->>'model')::character varying,
serial_number = (json_data->>'serial_number')::character varying,
equipment_type_id = (json_data->>'equipment_type_id')::integer,
person_id = (json_data->>'person_id')::integer,
nickname = (json_data->>'nickname')::character varying
WHERE id = v_id;
RETURN v_id;
END $function$
*/
}
/**
* @function data_geometry_type_c
* @memberof zzglc
* @description Data geometry type c
* @param {character_varying} Json
* @returns {void}
*/
function data_geometry_type_c() {
/*
CREATE OR REPLACE FUNCTION zzglc.data_geometry_type_c("Json" character varying)
RETURNS void
LANGUAGE plpgsql
AS $function$
BEGIN
INSERT INTO data.geometry_type (
name
)
SELECT
U.name
FROM
json_to_record("Json"::json) U (
name character varying(255)
)
;
END $function$
*/
}
/**
* @function data_geometry_type_d
* @memberof zzglc
* @description Data geometry type d
* @param {integer} Key
* @returns {void}
*/
function data_geometry_type_d() {
/*
CREATE OR REPLACE FUNCTION zzglc.data_geometry_type_d("Key" integer)
RETURNS void
LANGUAGE plpgsql
AS $function$
BEGIN
DELETE FROM data.geometry_type
WHERE id = "Key";
END $function$
*/
}
/**
* @function data_geometry_type_property_c
* @memberof zzglc
* @description Data geometry type property c
* @param {character_varying} Json
* @returns {void}
*/
function data_geometry_type_property_c() {
/*
CREATE OR REPLACE FUNCTION zzglc.data_geometry_type_property_c("Json" character varying)
RETURNS void
LANGUAGE plpgsql
AS $function$
BEGIN
INSERT INTO data.geometry_type_property (
geometry_type_id,
order_no,
property_id
)
SELECT
U.geometry_type_id,
U.order_no,
U.property_id
FROM
json_to_record("Json"::json) U (
geometry_type_id integer,
order_no integer,
property_id integer
)
;
END $function$
*/
}
/**
* @function data_geometry_type_property_d
* @memberof zzglc
* @description Data geometry type property d
* @param {integer} Key
* @returns {void}
*/
function data_geometry_type_property_d() {
/*
CREATE OR REPLACE FUNCTION zzglc.data_geometry_type_property_d("Key" integer)
RETURNS void
LANGUAGE plpgsql
AS $function$
BEGIN
DELETE FROM data.geometry_type_property
WHERE id = "Key";
END $function$
*/
}
/**
* @function data_geometry_type_property_r
* @memberof zzglc
* @description Data geometry type property r
* @returns {Object}
* @property {integer} id
* @property {integer} geometry_type_id
* @property {integer} order_no
* @property {integer} property_id
* @property {character_varying} geometry_type_id_val
* @property {character_varying} property_id_val
*/
function data_geometry_type_property_r() {
/*
CREATE OR REPLACE FUNCTION zzglc.data_geometry_type_property_r()
RETURNS TABLE(id integer, geometry_type_id integer, order_no integer, property_id integer, geometry_type_id_val character varying, property_id_val character varying)
LANGUAGE plpgsql
AS $function$
BEGIN
RETURN QUERY
SELECT
t.id, t.geometry_type_id, t.order_no, t.property_id
, geometry_type_id_t.name::VARCHAR AS geometry_type_id_val
, COALESCE(i.name, property_id_t.name)::VARCHAR AS property_id_val
FROM data.geometry_type_property t
LEFT JOIN data.geometry_type geometry_type_id_t ON geometry_type_id_t.id = t.geometry_type_id
LEFT JOIN data.property property_id_t ON property_id_t.id = t.property_id
LEFT JOIN data.indicator i ON i.id = property_id_t.indicator_id
ORDER BY geometry_type_id_t.name, t.order_no
;
END $function$
*/
}
/**
* @function data_geometry_type_property_u
* @memberof zzglc
* @description Data geometry type property u
* @param {character_varying} Json
* @returns {void}
*/
function data_geometry_type_property_u() {
/*
CREATE OR REPLACE FUNCTION zzglc.data_geometry_type_property_u("Json" character varying)
RETURNS void
LANGUAGE plpgsql
AS $function$
DECLARE v_row_count INTEGER;
BEGIN
UPDATE data.geometry_type_property t
SET geometry_type_id = U.geometry_type_id,
order_no = U.order_no,
property_id = U.property_id
FROM json_to_record("Json"::json) AS U (
id integer,
geometry_type_id integer,
order_no integer,
property_id integer
)
WHERE U.id = t.id
;
END $function$
*/
}
/**
* @function data_geometry_type_r
* @memberof zzglc
* @description Data geometry type r
* @returns {Object}
* @property {integer} id
* @property {character_varying} name
*/
function data_geometry_type_r() {
/*
CREATE OR REPLACE FUNCTION zzglc.data_geometry_type_r()
RETURNS TABLE(id integer, name character varying)
LANGUAGE plpgsql
AS $function$
BEGIN
RETURN QUERY
SELECT
t.id, t.name
FROM data.geometry_type t
;
END $function$
*/
}
/**
* @function data_geometry_type_u
* @memberof zzglc
* @description Data geometry type u
* @param {character_varying} Json
* @returns {void}
*/
function data_geometry_type_u() {
/*
CREATE OR REPLACE FUNCTION zzglc.data_geometry_type_u("Json" character varying)
RETURNS void
LANGUAGE plpgsql
AS $function$
DECLARE v_row_count INTEGER;
BEGIN
UPDATE data.geometry_type t
SET name = U.name
FROM json_to_record("Json"::json) AS U (
id integer,
name character varying(255)
)
WHERE U.id = t.id
;
END $function$
*/
}
/**
* @function data_image_c
* @memberof zzglc
* @description Data image c
* @param {character_varying} Json
* @returns {integer}
*/
function data_image_c() {
/*
CREATE OR REPLACE FUNCTION zzglc.data_image_c("Json" character varying)
RETURNS integer
LANGUAGE plpgsql
AS $function$
DECLARE v_id integer;
DECLARE json_data json;
BEGIN
json_data := "Json";
INSERT INTO data.image (name, image_approach_id, image_substrate_id, image_camera_id, image_setup_id, image_lightsource_id, file_name, extension, mime_type, compass, lat, lon, time_created, time_modified, pitch, sample_id, simple_observation_id)
VALUES ((json_data->>'name')::character varying, (json_data->>'image_approach_id')::integer, (json_data->>'image_substrate_id')::integer, (json_data->>'image_camera_id')::integer, (json_data->>'image_setup_id')::integer, (json_data->>'image_lightsource_id')::integer, (json_data->>'file_name')::character varying, (json_data->>'extension')::character varying, (json_data->>'mime_type')::character varying, (json_data->>'compass')::integer, (json_data->>'lat')::double precision, (json_data->>'lon')::double precision, (json_data->>'time_created')::timestamp with time zone, (json_data->>'time_modified')::timestamp with time zone, (json_data->>'pitch')::integer, (json_data->>'sample_id')::integer, (json_data->>'simple_observation_id')::integer)
RETURNING id INTO v_id;
RETURN v_id;
END $function$
*/
}
/**
* @function data_image_d
* @memberof zzglc
* @description Data image d
* @param {integer} Key
* @returns {void}
*/
function data_image_d() {
/*
CREATE OR REPLACE FUNCTION zzglc.data_image_d("Key" integer)
RETURNS void
LANGUAGE plpgsql
AS $function$
BEGIN
DELETE FROM data.image WHERE id = "Key";
END;
$function$
*/
}
/**
* @function data_image_r
* @memberof zzglc
* @description Data image r
* @param {integer} Key
* @returns {Object} integer idcharacter_varying nameinteger catalog_image_approach__image_approach_idinteger catalog_image_substrate__image_substrate_idinteger catalog_image_camera__image_camera_idinteger catalog_image_setup__image_setup_idinteger catalog_image_lightsource__image_lightsource_idcharacter_varying file_namecharacter_varying extensioncharacter_varying mime_typeinteger compassdouble_precision latdouble_precision lontimestamp_with_time_zone time_createdtimestamp_with_time_zone time_modifiedinteger pitchinteger data_sample__sample_idinteger data_simple_observation__simple_observation_idcharacter_varying catalog_image_approach__image_approach_id_valcharacter_varying catalog_image_substrate__image_substrate_id_valcharacter_varying catalog_image_camera__image_camera_id_valcharacter_varying catalog_image_setup__image_setup_id_valcharacter_varying catalog_image_lightsource__image_lightsource_id_valcharacter_varying data_sample__sample_id_valcharacter_varying data_simple_observation__simple_observation_id_val
*/
function data_image_r() {
/*
CREATE OR REPLACE FUNCTION zzglc.data_image_r("Key" integer)
RETURNS TABLE(id integer, name character varying, catalog_image_approach__image_approach_id integer, catalog_image_substrate__image_substrate_id integer, catalog_image_camera__image_camera_id integer, catalog_image_setup__image_setup_id integer, catalog_image_lightsource__image_lightsource_id integer, file_name character varying, extension character varying, mime_type character varying, compass integer, lat double precision, lon double precision, time_created timestamp with time zone, time_modified timestamp with time zone, pitch integer, data_sample__sample_id integer, data_simple_observation__simple_observation_id integer, catalog_image_approach__image_approach_id_val character varying, catalog_image_substrate__image_substrate_id_val character varying, catalog_image_camera__image_camera_id_val character varying, catalog_image_setup__image_setup_id_val character varying, catalog_image_lightsource__image_lightsource_id_val character varying, data_sample__sample_id_val character varying, data_simple_observation__simple_observation_id_val character varying)
LANGUAGE plpgsql
AS $function$
BEGIN
RETURN QUERY (
SELECT t.id, t.name, t.image_approach_id, t.image_substrate_id, t.image_camera_id, t.image_setup_id, t.image_lightsource_id, t.file_name, t.extension, t.mime_type, t.compass, t.lat, t.lon, t.time_created, t.time_modified, t.pitch, t.sample_id, t.simple_observation_id, image_approach_id.name, image_substrate_id.name, image_camera_id.name, image_setup_id.name, image_lightsource_id.name, sample_id.name, simple_observation_id.name
FROM data.image t
LEFT JOIN catalog.image_approach image_approach_id ON image_approach_id.id = t.image_approach_id
LEFT JOIN catalog.image_substrate image_substrate_id ON image_substrate_id.id = t.image_substrate_id
LEFT JOIN catalog.image_camera image_camera_id ON image_camera_id.id = t.image_camera_id
LEFT JOIN catalog.image_setup image_setup_id ON image_setup_id.id = t.image_setup_id
LEFT JOIN catalog.image_lightsource image_lightsource_id ON image_lightsource_id.id = t.image_lightsource_id
LEFT JOIN data.sample sample_id ON sample_id.id = t.sample_id
LEFT JOIN data.simple_observation simple_observation_id ON simple_observation_id.id = t.simple_observation_id
WHERE t.sample_id = "Key"
ORDER BY 2
);
END $function$
*/
}
/**
* @function data_image_r_overload
* @overload data_image_r
* @memberof zzglc
* @description Data image r
* @returns {Object} integer idcharacter_varying nameinteger catalog_image_approach__image_approach_idinteger catalog_image_substrate__image_substrate_idinteger catalog_image_camera__image_camera_idinteger catalog_image_setup__image_setup_idinteger catalog_image_lightsource__image_lightsource_idcharacter_varying file_namecharacter_varying extensioncharacter_varying mime_typeinteger compassdouble_precision latdouble_precision lontimestamp_with_time_zone time_createdtimestamp_with_time_zone time_modifiedinteger pitchinteger data_sample__sample_idinteger data_simple_observation__simple_observation_idcharacter_varying catalog_image_approach__image_approach_id_valcharacter_varying catalog_image_substrate__image_substrate_id_valcharacter_varying catalog_image_camera__image_camera_id_valcharacter_varying catalog_image_setup__image_setup_id_valcharacter_varying catalog_image_lightsource__image_lightsource_id_valcharacter_varying data_sample__sample_id_valcharacter_varying data_simple_observation__simple_observation_id_val
*/
function data_image_r_overload() {
/*
CREATE OR REPLACE FUNCTION zzglc.data_image_r()
RETURNS TABLE(id integer, name character varying, catalog_image_approach__image_approach_id integer, catalog_image_substrate__image_substrate_id integer, catalog_image_camera__image_camera_id integer, catalog_image_setup__image_setup_id integer, catalog_image_lightsource__image_lightsource_id integer, file_name character varying, extension character varying, mime_type character varying, compass integer, lat double precision, lon double precision, time_created timestamp with time zone, time_modified timestamp with time zone, pitch integer, data_sample__sample_id integer, data_simple_observation__simple_observation_id integer, catalog_image_approach__image_approach_id_val character varying, catalog_image_substrate__image_substrate_id_val character varying, catalog_image_camera__image_camera_id_val character varying, catalog_image_setup__image_setup_id_val character varying, catalog_image_lightsource__image_lightsource_id_val character varying, data_sample__sample_id_val character varying, data_simple_observation__simple_observation_id_val character varying)
LANGUAGE plpgsql
AS $function$
BEGIN
RETURN QUERY (
SELECT t.id, t.name, t.image_approach_id, t.image_substrate_id, t.image_camera_id, t.image_setup_id, t.image_lightsource_id, t.file_name, t.extension, t.mime_type, t.compass, t.lat, t.lon, t.time_created, t.time_modified, t.pitch, t.sample_id, t.simple_observation_id, image_approach_id.name, image_substrate_id.name, image_camera_id.name, image_setup_id.name, image_lightsource_id.name, sample_id.name, simple_observation_id.name
FROM data.image t
LEFT JOIN catalog.image_approach image_approach_id ON image_approach_id.id = t.image_approach_id
LEFT JOIN catalog.image_substrate image_substrate_id ON image_substrate_id.id = t.image_substrate_id
LEFT JOIN catalog.image_camera image_camera_id ON image_camera_id.id = t.image_camera_id
LEFT JOIN catalog.image_setup image_setup_id ON image_setup_id.id = t.image_setup_id
LEFT JOIN catalog.image_lightsource image_lightsource_id ON image_lightsource_id.id = t.image_lightsource_id
LEFT JOIN data.sample sample_id ON sample_id.id = t.sample_id
LEFT JOIN data.simple_observation simple_observation_id ON simple_observation_id.id = t.simple_observation_id
ORDER BY 2
);
END $function$
*/
}
/**
* @function data_image_u
* @memberof zzglc
* @description Data image u
* @param {character_varying} Json
* @returns {integer}
*/
function data_image_u() {
/*
CREATE OR REPLACE FUNCTION zzglc.data_image_u("Json" character varying)
RETURNS integer
LANGUAGE plpgsql
AS $function$
DECLARE v_id integer;
DECLARE json_data json;
BEGIN
json_data := "Json";
v_id := (json_data->>'id')::integer;
UPDATE data.image SET
name = (json_data->>'name')::character varying,
image_approach_id = (json_data->>'image_approach_id')::integer,
image_substrate_id = (json_data->>'image_substrate_id')::integer,
image_camera_id = (json_data->>'image_camera_id')::integer,
image_setup_id = (json_data->>'image_setup_id')::integer,
image_lightsource_id = (json_data->>'image_lightsource_id')::integer,
file_name = (json_data->>'file_name')::character varying,
extension = (json_data->>'extension')::character varying,
mime_type = (json_data->>'mime_type')::character varying,
compass = (json_data->>'compass')::integer,
lat = (json_data->>'lat')::double precision,
lon = (json_data->>'lon')::double precision,
time_created = (json_data->>'time_created')::timestamp with time zone,
time_modified = (json_data->>'time_modified')::timestamp with time zone,
pitch = (json_data->>'pitch')::integer,
sample_id = (json_data->>'sample_id')::integer,
simple_observation_id = (json_data->>'simple_observation_id')::integer
WHERE id = v_id;
RETURN v_id;
END $function$
*/
}
/**
* @function data_import_procedure_c
* @memberof zzglc
* @description Data import procedure c
* @param {character_varying} Json
* @returns {integer}
*/
function data_import_procedure_c() {
/*
CREATE OR REPLACE FUNCTION zzglc.data_import_procedure_c("Json" character varying)
RETURNS integer
LANGUAGE plpgsql
AS $function$
DECLARE v_id integer;
DECLARE json_data json;
BEGIN
json_data := "Json";
INSERT INTO data.import_procedure (proc_name, sheet, preprocess, data_source_id, date)
VALUES ((json_data->>'proc_name')::character varying, (json_data->>'sheet')::character varying, (json_data->>'preprocess')::character varying, (json_data->>'data_source_id')::integer, (json_data->>'date')::date)
RETURNING id INTO v_id;
RETURN v_id;
END $function$
*/
}
/**
* @function data_import_procedure_d
* @memberof zzglc
* @description Data import procedure d
* @param {integer} Key
* @returns {void}
*/
function data_import_procedure_d() {
/*
CREATE OR REPLACE FUNCTION zzglc.data_import_procedure_d("Key" integer)
RETURNS void
LANGUAGE plpgsql
AS $function$
BEGIN
DELETE FROM data.import_procedure WHERE id = "Key";
END;
$function$
*/
}
/**
* @function data_import_procedure_r
* @memberof zzglc
* @description Data import procedure r
* @returns {Object} integer idcharacter_varying proc_namecharacter_varying sheetcharacter_varying preprocessinteger data_data_source__data_source_iddate datecharacter_varying data_data_source__data_source_id_val
*/
function data_import_procedure_r() {
/*
CREATE OR REPLACE FUNCTION zzglc.data_import_procedure_r()
RETURNS TABLE(id integer, proc_name character varying, sheet character varying, preprocess character varying, data_data_source__data_source_id integer, date date, data_data_source__data_source_id_val character varying)
LANGUAGE plpgsql
AS $function$
BEGIN
RETURN QUERY (
SELECT t.id, t.proc_name, t.sheet, t.preprocess, t.data_source_id, t.date, data_source_id.name
FROM data.import_procedure t
LEFT JOIN data.data_source data_source_id ON data_source_id.id = t.data_source_id
);
END $function$
*/
}
/**
* @function data_import_procedure_u
* @memberof zzglc
* @description Data import procedure u
* @param {character_varying} Json
* @returns {void}
*/
function data_import_procedure_u() {
/*
CREATE OR REPLACE FUNCTION zzglc.data_import_procedure_u("Json" character varying)
RETURNS void
LANGUAGE plpgsql
AS $function$
DECLARE json_data json;
BEGIN
json_data := "Json";
UPDATE data.import_procedure SET
proc_name = (json_data->>'proc_name')::character varying,
sheet = (json_data->>'sheet')::character varying,
preprocess = (json_data->>'preprocess')::character varying,
data_source_id = (json_data->>'data_source_id')::integer,
date = (json_data->>'date')::date
WHERE id = (json_data->>'id')::integer;
END $function$
*/
}
/**
* @function data_indicator_c
* @memberof zzglc
* @description Data indicator c
* @param {character_varying} Json
* @returns {integer}
*/
function data_indicator_c() {
/*
CREATE OR REPLACE FUNCTION zzglc.data_indicator_c("Json" character varying)
RETURNS integer
LANGUAGE plpgsql
AS $function$
DECLARE v_id integer;
DECLARE json_data json;
BEGIN
json_data := "Json";
INSERT INTO data.indicator (display_name, unit_id, lod, name, decimals_for_stats, decimals_for_display, numerical, value_from, value_to, data_type_id, simple_observation, description)
VALUES ((json_data->>'display_name')::character varying, (json_data->>'unit_id')::integer, (json_data->>'lod')::character varying, (json_data->>'name')::character varying, (json_data->>'decimals_for_stats')::integer, (json_data->>'decimals_for_display')::integer, (json_data->>'numerical')::boolean, (json_data->>'value_from')::real, (json_data->>'value_to')::real, (json_data->>'data_type_id')::integer, (json_data->>'simple_observation')::boolean, (json_data->>'description')::character varying)
RETURNING id INTO v_id;
RETURN v_id;
END $function$
*/
}
/**
* @function data_indicator_color_c
* @memberof zzglc
* @description Data indicator color c
* @param {character_varying} Json
* @returns {void}
*/
function data_indicator_color_c() {
/*
CREATE OR REPLACE FUNCTION zzglc.data_indicator_color_c("Json" character varying)
RETURNS void
LANGUAGE plpgsql
AS $function$
BEGIN
INSERT INTO data.indicator_color (
indicator_id,
value_to,
color_id
)
SELECT
U.indicator_id,
U.value_to,
U.color_id
FROM
json_to_record("Json"::json) U (
indicator_id integer,
value_to real,
color_id integer
)
;
END $function$
*/
}
/**
* @function data_indicator_color_d
* @memberof zzglc
* @description Data indicator color d
* @param {integer} Key
* @returns {void}
*/
function data_indicator_color_d() {
/*
CREATE OR REPLACE FUNCTION zzglc.data_indicator_color_d("Key" integer)
RETURNS void
LANGUAGE plpgsql
AS $function$
BEGIN
DELETE FROM data.indicator_color
WHERE id = "Key";
END $function$
*/
}
/**
* @function data_indicator_color_r
* @memberof zzglc
* @description Data indicator color r
* @param {integer} Key
* @returns {Object} integer idinteger data_indicator__indicator_idreal value_tointeger general_color__color_idcharacter_varying data_indicator__indicator_id_valcharacter_varying general_color__color_id_val
*/
function data_indicator_color_r() {
/*
CREATE OR REPLACE FUNCTION zzglc.data_indicator_color_r("Key" integer)
RETURNS TABLE(id integer, data_indicator__indicator_id integer, value_to real, general_color__color_id integer, data_indicator__indicator_id_val character varying, general_color__color_id_val character varying)
LANGUAGE plpgsql
AS $function$
BEGIN
RETURN QUERY (
SELECT t.id, t.indicator_id, t.value_to, t.color_id, indicator_id.display_name, color_id.name
FROM data.indicator_color t
LEFT JOIN data.indicator indicator_id ON indicator_id.id = t.indicator_id
LEFT JOIN general.color color_id ON color_id.id = t.color_id
WHERE t.indicator_id = "Key"
ORDER BY 2
);
END $function$
*/
}
/**
* @function data_indicator_color_r_overload
* @overload data_indicator_color_r
* @memberof zzglc
* @description Data indicator color r
* @returns {Object}
* @property {integer} id
* @property {integer} indicator_id
* @property {real} value_to
* @property {integer} color_id
* @property {character_varying} indicator_id_val
* @property {character_varying} color_id_val
* @property {character_varying} color_code
*/
function data_indicator_color_r_overload() {
/*
CREATE OR REPLACE FUNCTION zzglc.data_indicator_color_r()
RETURNS TABLE(id integer, indicator_id integer, value_to real, general_color__color_id integer, indicator_id_val character varying, general_color__color_id_val character varying, color_code character varying)
LANGUAGE plpgsql
AS $function$
BEGIN
RETURN QUERY
SELECT
t.id, t.indicator_id, t.value_to, t.color_id
, indicator_id_t.name::VARCHAR AS indicator_id_val, color_id_t.name::VARCHAR AS color_id_val, color_id_t.code
FROM data.indicator_color t
LEFT JOIN data.indicator indicator_id_t ON indicator_id_t.id = t.indicator_id
LEFT JOIN general.color color_id_t ON color_id_t.id = t.color_id
ORDER BY t.indicator_id, t.value_to
;
END $function$
*/
}
/**
* @function data_indicator_color_u
* @memberof zzglc
* @description Data indicator color u
* @param {character_varying} Json
* @returns {void}
*/
function data_indicator_color_u() {
/*
CREATE OR REPLACE FUNCTION zzglc.data_indicator_color_u("Json" character varying)
RETURNS void
LANGUAGE plpgsql
AS $function$
DECLARE v_row_count INTEGER;
BEGIN
UPDATE data.indicator_color t
SET indicator_id = U.indicator_id,
value_to = U.value_to,
color_id = U.color_id
FROM json_to_record("Json"::json) AS U (
id integer,
indicator_id integer,
value_to real,
color_id integer
)
WHERE U.id = t.id
;
END $function$
*/
}
/**
* @function data_indicator_d
* @memberof zzglc
* @description Data indicator d
* @param {integer} Key
* @returns {void}
*/
function data_indicator_d() {
/*
CREATE OR REPLACE FUNCTION zzglc.data_indicator_d("Key" integer)
RETURNS void
LANGUAGE plpgsql
AS $function$
BEGIN
DELETE FROM data.indicator WHERE id = "Key";
END;
$function$
*/
}
/**
* @function data_indicator_lang_c
* @memberof zzglc
* @description Data indicator lang c
* @param {character_varying} Json
* @returns {integer}
*/
function data_indicator_lang_c() {
/*
CREATE OR REPLACE FUNCTION zzglc.data_indicator_lang_c("Json" character varying)
RETURNS integer
LANGUAGE plpgsql
AS $function$
DECLARE v_id integer;
DECLARE json_data json;
BEGIN
json_data := "Json";
INSERT INTO data.indicator_lang (indicator_id, lang_id, value)
VALUES ((json_data->>'indicator_id')::integer, (json_data->>'lang_id')::integer, (json_data->>'value')::character varying)
RETURNING id INTO v_id;
RETURN v_id;
END $function$
*/
}
/**
* @function data_indicator_lang_d
* @memberof zzglc
* @description Data indicator lang d
* @param {integer} Key
* @returns {void}
*/
function data_indicator_lang_d() {
/*
CREATE OR REPLACE FUNCTION zzglc.data_indicator_lang_d("Key" integer)
RETURNS void
LANGUAGE plpgsql
AS $function$
BEGIN
DELETE FROM data.indicator_lang WHERE id = "Key";
END;
$function$
*/
}
/**
* @function data_indicator_lang_r
* @memberof zzglc
* @description Data indicator lang r
* @param {integer} Key
* @returns {Object} integer idinteger data_indicator__indicator_idinteger meta_lang__lang_idcharacter_varying valuecharacter_varying data_indicator__indicator_id_valcharacter_varying meta_lang__lang_id_val
*/
function data_indicator_lang_r() {
/*
CREATE OR REPLACE FUNCTION zzglc.data_indicator_lang_r("Key" integer)
RETURNS TABLE(id integer, data_indicator__indicator_id integer, meta_lang__lang_id integer, value character varying, data_indicator__indicator_id_val character varying, meta_lang__lang_id_val character varying)
LANGUAGE plpgsql
AS $function$
BEGIN
RETURN QUERY (
SELECT t.id, t.indicator_id, t.lang_id, t.value, indicator_id.display_name, lang_id.name
FROM data.indicator_lang t
LEFT JOIN data.indicator indicator_id ON indicator_id.id = t.indicator_id
LEFT JOIN meta.lang lang_id ON lang_id.id = t.lang_id
WHERE t.indicator_id = "Key"
ORDER BY 2
);
END $function$
*/
}
/**
* @function data_indicator_lang_r_overload
* @overload data_indicator_lang_r
* @memberof zzglc
* @description Data indicator lang r
* @returns {Object} integer idinteger data_indicator__indicator_idinteger meta_lang__lang_idcharacter_varying valuecharacter_varying data_indicator__indicator_id_valcharacter_varying meta_lang__lang_id_val
*/
function data_indicator_lang_r_overload() {
/*
CREATE OR REPLACE FUNCTION zzglc.data_indicator_lang_r()
RETURNS TABLE(id integer, data_indicator__indicator_id integer, meta_lang__lang_id integer, value character varying, data_indicator__indicator_id_val character varying, meta_lang__lang_id_val character varying)
LANGUAGE plpgsql
AS $function$
BEGIN
RETURN QUERY (
SELECT t.id, t.indicator_id, t.lang_id, t.value, indicator_id.display_name, lang_id.name
FROM data.indicator_lang t
LEFT JOIN data.indicator indicator_id ON indicator_id.id = t.indicator_id
LEFT JOIN meta.lang lang_id ON lang_id.id = t.lang_id
ORDER BY 2
);
END $function$
*/
}
/**
* @function data_indicator_lang_u
* @memberof zzglc
* @description Data indicator lang u
* @param {character_varying} Json
* @returns {integer}
*/
function data_indicator_lang_u() {
/*
CREATE OR REPLACE FUNCTION zzglc.data_indicator_lang_u("Json" character varying)
RETURNS integer
LANGUAGE plpgsql
AS $function$
DECLARE v_id integer;
DECLARE json_data json;
BEGIN
json_data := "Json";
v_id := (json_data->>'id')::integer;
UPDATE data.indicator_lang SET
indicator_id = (json_data->>'indicator_id')::integer,
lang_id = (json_data->>'lang_id')::integer,
value = (json_data->>'value')::character varying
WHERE id = v_id;
RETURN v_id;
END $function$
*/
}
/**
* @function data_indicator_r
* @memberof zzglc
* @description Data indicator r
* @returns {Object} integer idcharacter_varying display_nameinteger catalog_unit__unit_idcharacter_varying lodcharacter_varying nameinteger decimals_for_statsinteger decimals_for_displayboolean numericalreal value_fromreal value_tointeger data_type_idboolean simple_observationcharacter_varying descriptioncharacter_varying catalog_unit__unit_id_val
*/
function data_indicator_r() {
/*
CREATE OR REPLACE FUNCTION zzglc.data_indicator_r()
RETURNS TABLE(id integer, display_name character varying, catalog_unit__unit_id integer, lod character varying, name character varying, decimals_for_stats integer, decimals_for_display integer, numerical boolean, value_from real, value_to real, data_type_id integer, simple_observation boolean, description character varying, catalog_unit__unit_id_val character varying)
LANGUAGE plpgsql
AS $function$
BEGIN
RETURN QUERY (
SELECT t.id, t.display_name, t.unit_id, t.lod, t.name, t.decimals_for_stats, t.decimals_for_display, t.numerical, t.value_from, t.value_to, t.data_type_id, t.simple_observation, t.description, unit_id.display_name
FROM data.indicator t
LEFT JOIN catalog.unit unit_id ON unit_id.id = t.unit_id
ORDER BY 2
);
END $function$
*/
}
/**
* @function data_indicator_u
* @memberof zzglc
* @description Data indicator u
* @param {character_varying} Json
* @returns {integer}
*/
function data_indicator_u() {
/*
CREATE OR REPLACE FUNCTION zzglc.data_indicator_u("Json" character varying)
RETURNS integer
LANGUAGE plpgsql
AS $function$
DECLARE v_id integer;
DECLARE json_data json;
BEGIN
json_data := "Json";
v_id := (json_data->>'id')::integer;
UPDATE data.indicator SET
display_name = (json_data->>'display_name')::character varying,
unit_id = (json_data->>'unit_id')::integer,
lod = (json_data->>'lod')::character varying,
name = (json_data->>'name')::character varying,
decimals_for_stats = (json_data->>'decimals_for_stats')::integer,
decimals_for_display = (json_data->>'decimals_for_display')::integer,
numerical = (json_data->>'numerical')::boolean,
value_from = (json_data->>'value_from')::real,
value_to = (json_data->>'value_to')::real,
data_type_id = (json_data->>'data_type_id')::integer,
simple_observation = (json_data->>'simple_observation')::boolean,
description = (json_data->>'description')::character varying
WHERE id = v_id;
RETURN v_id;
END $function$
*/
}
/**
* @function data_infiltration_c
* @memberof zzglc
* @description Data infiltration c
* @param {character_varying} Json
* @returns {integer}
*/
function data_infiltration_c() {
/*
CREATE OR REPLACE FUNCTION zzglc.data_infiltration_c("Json" character varying)
RETURNS integer
LANGUAGE plpgsql
AS $function$
DECLARE v_id integer;
DECLARE json_data json;
BEGIN
json_data := "Json";
INSERT INTO data.infiltration (soil_moisture_after_infiltration, ring_diameter, unit_volume, soil_moisture_method_id, observation_id, saturated_conductivity, field_capacity, wilting_point, water_content, water_potential)
VALUES ((json_data->>'soil_moisture_after_infiltration')::double precision, (json_data->>'ring_diameter')::double precision, (json_data->>'unit_volume')::integer, (json_data->>'soil_moisture_method_id')::integer, (json_data->>'observation_id')::integer, (json_data->>'saturated_conductivity')::real, (json_data->>'field_capacity')::real, (json_data->>'wilting_point')::real, (json_data->>'water_content')::real, (json_data->>'water_potential')::real)
RETURNING id INTO v_id;
RETURN v_id;
END $function$
*/
}
/**
* @function data_infiltration_d
* @memberof zzglc
* @description Data infiltration d
* @param {integer} Key
* @returns {void}
*/
function data_infiltration_d() {
/*
CREATE OR REPLACE FUNCTION zzglc.data_infiltration_d("Key" integer)
RETURNS void
LANGUAGE plpgsql
AS $function$
BEGIN
DELETE FROM data.infiltration WHERE id = "Key";
END;
$function$
*/
}
/**
* @function data_infiltration_r
* @memberof zzglc
* @description Data infiltration r
* @param {integer} Key
* @returns {Object} integer iddouble_precision soil_moisture_after_infiltrationdouble_precision ring_diameterinteger unit_volumeinteger catalog_soil_moisture_method__soil_moisture_method_idinteger data_observation__observation_idreal saturated_conductivityreal field_capacityreal wilting_pointreal water_contentreal water_potentialcharacter_varying catalog_soil_moisture_method__soil_moisture_method_id_valcharacter_varying data_observation__observation_id_val
*/
function data_infiltration_r() {
/*
CREATE OR REPLACE FUNCTION zzglc.data_infiltration_r("Key" integer)
RETURNS TABLE(id integer, soil_moisture_after_infiltration double precision, ring_diameter double precision, unit_volume integer, catalog_soil_moisture_method__soil_moisture_method_id integer, data_observation__observation_id integer, saturated_conductivity real, field_capacity real, wilting_point real, water_content real, water_potential real, catalog_soil_moisture_method__soil_moisture_method_id_val character varying, data_observation__observation_id_val character varying)
LANGUAGE plpgsql
AS $function$
BEGIN
RETURN QUERY (
SELECT t.id, t.soil_moisture_after_infiltration, t.ring_diameter, t.unit_volume, t.soil_moisture_method_id, t.observation_id, t.saturated_conductivity, t.field_capacity, t.wilting_point, t.water_content, t.water_potential, soil_moisture_method_id.name, observation_id.comment
FROM data.infiltration t
LEFT JOIN catalog.soil_moisture_method soil_moisture_method_id ON soil_moisture_method_id.id = t.soil_moisture_method_id
LEFT JOIN data.observation observation_id ON observation_id.id = t.observation_id
WHERE t.observation_id = "Key"
ORDER BY 2
);
END $function$
*/
}
/**
* @function data_infiltration_r_overload
* @overload data_infiltration_r
* @memberof zzglc
* @description Data infiltration r
* @returns {Object} integer iddouble_precision soil_moisture_after_infiltrationdouble_precision ring_diameterinteger unit_volumeinteger catalog_soil_moisture_method__soil_moisture_method_idinteger data_observation__observation_idreal saturated_conductivityreal field_capacityreal wilting_pointreal water_contentreal water_potentialcharacter_varying catalog_soil_moisture_method__soil_moisture_method_id_valcharacter_varying data_observation__observation_id_val
*/
function data_infiltration_r_overload() {
/*
CREATE OR REPLACE FUNCTION zzglc.data_infiltration_r()
RETURNS TABLE(id integer, soil_moisture_after_infiltration double precision, ring_diameter double precision, unit_volume integer, catalog_soil_moisture_method__soil_moisture_method_id integer, data_observation__observation_id integer, saturated_conductivity real, field_capacity real, wilting_point real, water_content real, water_potential real, catalog_soil_moisture_method__soil_moisture_method_id_val character varying, data_observation__observation_id_val character varying)
LANGUAGE plpgsql
AS $function$
BEGIN
RETURN QUERY (
SELECT t.id, t.soil_moisture_after_infiltration, t.ring_diameter, t.unit_volume, t.soil_moisture_method_id, t.observation_id, t.saturated_conductivity, t.field_capacity, t.wilting_point, t.water_content, t.water_potential, soil_moisture_method_id.name, observation_id.comment
FROM data.infiltration t
LEFT JOIN catalog.soil_moisture_method soil_moisture_method_id ON soil_moisture_method_id.id = t.soil_moisture_method_id
LEFT JOIN data.observation observation_id ON observation_id.id = t.observation_id
ORDER BY 2
);
END $function$
*/
}
/**
* @function data_infiltration_time_c
* @memberof zzglc
* @description Data infiltration time c
* @param {character_varying} Json
* @returns {integer}
*/
function data_infiltration_time_c() {
/*
CREATE OR REPLACE FUNCTION zzglc.data_infiltration_time_c("Json" character varying)
RETURNS integer
LANGUAGE plpgsql
AS $function$
DECLARE v_id integer;
DECLARE json_data json;
BEGIN
json_data := "Json";
INSERT INTO data.infiltration_time (infiltration_id, order_no, duration)
VALUES ((json_data->>'infiltration_id')::integer, (json_data->>'order_no')::smallint, (json_data->>'duration')::smallint)
RETURNING id INTO v_id;
RETURN v_id;
END $function$
*/
}
/**
* @function data_infiltration_time_d
* @memberof zzglc
* @description Data infiltration time d
* @param {integer} Key
* @returns {void}
*/
function data_infiltration_time_d() {
/*
CREATE OR REPLACE FUNCTION zzglc.data_infiltration_time_d("Key" integer)
RETURNS void
LANGUAGE plpgsql
AS $function$
BEGIN
DELETE FROM data.infiltration_time WHERE id = "Key";
END;
$function$
*/
}
/**
* @function data_infiltration_time_r
* @memberof zzglc
* @description Data infiltration time r
* @param {integer} Key
* @returns {Object} integer idinteger data_infiltration__infiltration_idsmallint order_nosmallint durationcharacter_varying data_infiltration__infiltration_id_val
*/
function data_infiltration_time_r() {
/*
CREATE OR REPLACE FUNCTION zzglc.data_infiltration_time_r("Key" integer)
RETURNS TABLE(id integer, data_infiltration__infiltration_id integer, order_no smallint, duration smallint, data_infiltration__infiltration_id_val character varying)
LANGUAGE plpgsql
AS $function$
BEGIN
RETURN QUERY (
SELECT t.id, t.infiltration_id, t.order_no, t.duration, infiltration_id.observation_id::varchar
FROM data.infiltration_time t
LEFT JOIN data.infiltration infiltration_id ON infiltration_id.id = t.infiltration_id
WHERE t.infiltration_id = "Key"
ORDER BY 2
);
END $function$
*/
}
/**
* @function data_infiltration_time_r_overload
* @overload data_infiltration_time_r
* @memberof zzglc
* @description Data infiltration time r
* @returns {Object} integer idinteger data_infiltration__infiltration_idsmallint order_nosmallint durationcharacter_varying data_infiltration__infiltration_id_val
*/
function data_infiltration_time_r_overload() {
/*
CREATE OR REPLACE FUNCTION zzglc.data_infiltration_time_r()
RETURNS TABLE(id integer, data_infiltration__infiltration_id integer, order_no smallint, duration smallint, data_infiltration__infiltration_id_val character varying)
LANGUAGE plpgsql
AS $function$
BEGIN
RETURN QUERY (
SELECT t.id, t.infiltration_id, t.order_no, t.duration, infiltration_id.observation_id::varchar
FROM data.infiltration_time t
LEFT JOIN data.infiltration infiltration_id ON infiltration_id.id = t.infiltration_id
ORDER BY 2
);
END $function$
*/
}
/**
* @function data_infiltration_time_u
* @memberof zzglc
* @description Data infiltration time u
* @param {character_varying} Json
* @returns {integer}
*/
function data_infiltration_time_u() {
/*
CREATE OR REPLACE FUNCTION zzglc.data_infiltration_time_u("Json" character varying)
RETURNS integer
LANGUAGE plpgsql
AS $function$
DECLARE v_id integer;
DECLARE json_data json;
BEGIN
json_data := "Json";
v_id := (json_data->>'id')::integer;
UPDATE data.infiltration_time SET
infiltration_id = (json_data->>'infiltration_id')::integer,
order_no = (json_data->>'order_no')::smallint,
duration = (json_data->>'duration')::smallint
WHERE id = v_id;
RETURN v_id;
END $function$
*/
}
/**
* @function data_infiltration_u
* @memberof zzglc
* @description Data infiltration u
* @param {character_varying} Json
* @returns {integer}
*/
function data_infiltration_u() {
/*
CREATE OR REPLACE FUNCTION zzglc.data_infiltration_u("Json" character varying)
RETURNS integer
LANGUAGE plpgsql
AS $function$
DECLARE v_id integer;
DECLARE json_data json;
BEGIN
json_data := "Json";
v_id := (json_data->>'id')::integer;
UPDATE data.infiltration SET
soil_moisture_after_infiltration = (json_data->>'soil_moisture_after_infiltration')::double precision,
ring_diameter = (json_data->>'ring_diameter')::double precision,
unit_volume = (json_data->>'unit_volume')::integer,
soil_moisture_method_id = (json_data->>'soil_moisture_method_id')::integer,
observation_id = (json_data->>'observation_id')::integer,
saturated_conductivity = (json_data->>'saturated_conductivity')::real,
field_capacity = (json_data->>'field_capacity')::real,
wilting_point = (json_data->>'wilting_point')::real,
water_content = (json_data->>'water_content')::real,
water_potential = (json_data->>'water_potential')::real
WHERE id = v_id;
RETURN v_id;
END $function$
*/
}
/**
* @function data_lab_analysis_method_c
* @memberof zzglc
* @description Data lab analysis method c
* @param {character_varying} Json
* @returns {integer}
*/
function data_lab_analysis_method_c() {
/*
CREATE OR REPLACE FUNCTION zzglc.data_lab_analysis_method_c("Json" character varying)
RETURNS integer
LANGUAGE plpgsql
AS $function$
DECLARE v_id integer;
DECLARE json_data json;
BEGIN
json_data := "Json";
INSERT INTO data.lab_analysis_method (name, usda_standard_id, fao_standard_id)
VALUES ((json_data->>'name')::character varying, (json_data->>'usda_standard_id')::integer, (json_data->>'fao_standard_id')::integer)
RETURNING id INTO v_id;
RETURN v_id;
END $function$
*/
}
/**
* @function data_lab_analysis_method_d
* @memberof zzglc
* @description Data lab analysis method d
* @param {integer} Key
* @returns {void}
*/
function data_lab_analysis_method_d() {
/*
CREATE OR REPLACE FUNCTION zzglc.data_lab_analysis_method_d("Key" integer)
RETURNS void
LANGUAGE plpgsql
AS $function$
BEGIN
DELETE FROM data.lab_analysis_method WHERE id = "Key";
END;
$function$
*/
}
/**
* @function data_lab_analysis_method_indicator_c
* @memberof zzglc
* @description Data lab analysis method indicator c
* @param {character_varying} Json
* @returns {integer}
*/
function data_lab_analysis_method_indicator_c() {
/*
CREATE OR REPLACE FUNCTION zzglc.data_lab_analysis_method_indicator_c("Json" character varying)
RETURNS integer
LANGUAGE plpgsql
AS $function$
DECLARE v_id integer;
DECLARE json_data json;
BEGIN
json_data := "Json";
INSERT INTO data.lab_analysis_method_indicator (lab_analysis_method_id, indicator_id, unit_id)
VALUES ((json_data->>'lab_analysis_method_id')::integer, (json_data->>'indicator_id')::integer, (json_data->>'unit_id')::integer)
RETURNING id INTO v_id;
RETURN v_id;
END $function$
*/
}
/**
* @function data_lab_analysis_method_indicator_d
* @memberof zzglc
* @description Data lab analysis method indicator d
* @param {integer} Key
* @returns {void}
*/
function data_lab_analysis_method_indicator_d() {
/*
CREATE OR REPLACE FUNCTION zzglc.data_lab_analysis_method_indicator_d("Key" integer)
RETURNS void
LANGUAGE plpgsql
AS $function$
BEGIN
DELETE FROM data.lab_analysis_method_indicator WHERE id = "Key";
END;
$function$
*/
}
/**
* @function data_lab_analysis_method_indicator_r
* @memberof zzglc
* @description Data lab analysis method indicator r
* @param {integer} Key
* @returns {Object} integer idinteger data_lab_analysis_method__lab_analysis_method_idinteger data_indicator__indicator_idinteger catalog_unit__unit_idcharacter_varying data_lab_analysis_method__lab_analysis_method_id_valcharacter_varying data_indicator__indicator_id_valcharacter_varying catalog_unit__unit_id_val
*/
function data_lab_analysis_method_indicator_r() {
/*
CREATE OR REPLACE FUNCTION zzglc.data_lab_analysis_method_indicator_r("Key" integer)
RETURNS TABLE(id integer, data_lab_analysis_method__lab_analysis_method_id integer, data_indicator__indicator_id integer, catalog_unit__unit_id integer, data_lab_analysis_method__lab_analysis_method_id_val character varying, data_indicator__indicator_id_val character varying, catalog_unit__unit_id_val character varying)
LANGUAGE plpgsql
AS $function$
BEGIN
RETURN QUERY (
SELECT t.id, t.lab_analysis_method_id, t.indicator_id, t.unit_id, lab_analysis_method_id.name, indicator_id.display_name, unit_id.display_name
FROM data.lab_analysis_method_indicator t
LEFT JOIN data.lab_analysis_method lab_analysis_method_id ON lab_analysis_method_id.id = t.lab_analysis_method_id
LEFT JOIN data.indicator indicator_id ON indicator_id.id = t.indicator_id
LEFT JOIN catalog.unit unit_id ON unit_id.id = t.unit_id
WHERE t.lab_analysis_method_id = "Key"
ORDER BY 2
);
END $function$
*/
}
/**
* @function data_lab_analysis_method_indicator_r_overload
* @overload data_lab_analysis_method_indicator_r
* @memberof zzglc
* @description Data lab analysis method indicator r
* @returns {Object} integer idinteger data_lab_analysis_method__lab_analysis_method_idinteger data_indicator__indicator_idinteger catalog_unit__unit_idcharacter_varying data_lab_analysis_method__lab_analysis_method_id_valcharacter_varying data_indicator__indicator_id_valcharacter_varying catalog_unit__unit_id_val
*/
function data_lab_analysis_method_indicator_r_overload() {
/*
CREATE OR REPLACE FUNCTION zzglc.data_lab_analysis_method_indicator_r()
RETURNS TABLE(id integer, data_lab_analysis_method__lab_analysis_method_id integer, data_indicator__indicator_id integer, catalog_unit__unit_id integer, data_lab_analysis_method__lab_analysis_method_id_val character varying, data_indicator__indicator_id_val character varying, catalog_unit__unit_id_val character varying)
LANGUAGE plpgsql
AS $function$
BEGIN
RETURN QUERY (
SELECT t.id, t.lab_analysis_method_id, t.indicator_id, t.unit_id, lab_analysis_method_id.name, indicator_id.display_name, unit_id.display_name
FROM data.lab_analysis_method_indicator t
LEFT JOIN data.lab_analysis_method lab_analysis_method_id ON lab_analysis_method_id.id = t.lab_analysis_method_id
LEFT JOIN data.indicator indicator_id ON indicator_id.id = t.indicator_id
LEFT JOIN catalog.unit unit_id ON unit_id.id = t.unit_id
ORDER BY 2
);
END $function$
*/
}
/**
* @function data_lab_analysis_method_indicator_u
* @memberof zzglc
* @description Data lab analysis method indicator u
* @param {character_varying} Json
* @returns {integer}
*/
function data_lab_analysis_method_indicator_u() {
/*
CREATE OR REPLACE FUNCTION zzglc.data_lab_analysis_method_indicator_u("Json" character varying)
RETURNS integer
LANGUAGE plpgsql
AS $function$
DECLARE v_id integer;
DECLARE json_data json;
BEGIN
json_data := "Json";
v_id := (json_data->>'id')::integer;
UPDATE data.lab_analysis_method_indicator SET
lab_analysis_method_id = (json_data->>'lab_analysis_method_id')::integer,
indicator_id = (json_data->>'indicator_id')::integer,
unit_id = (json_data->>'unit_id')::integer
WHERE id = v_id;
RETURN v_id;
END $function$
*/
}
/**
* @function data_lab_analysis_method_r
* @memberof zzglc
* @description Data lab analysis method r
* @returns {Object} integer idcharacter_varying nameinteger catalog_usda_standard__usda_standard_idinteger catalog_fao_standard__fao_standard_idcharacter_varying catalog_usda_standard__usda_standard_id_valcharacter_varying catalog_fao_standard__fao_standard_id_val
*/
function data_lab_analysis_method_r() {
/*
CREATE OR REPLACE FUNCTION zzglc.data_lab_analysis_method_r()
RETURNS TABLE(id integer, name character varying, catalog_usda_standard__usda_standard_id integer, catalog_fao_standard__fao_standard_id integer, catalog_usda_standard__usda_standard_id_val character varying, catalog_fao_standard__fao_standard_id_val character varying)
LANGUAGE plpgsql
AS $function$
BEGIN
RETURN QUERY (
SELECT t.id, t.name, t.usda_standard_id, t.fao_standard_id, usda_standard_id.name, fao_standard_id.name
FROM data.lab_analysis_method t
LEFT JOIN catalog.usda_standard usda_standard_id ON usda_standard_id.id = t.usda_standard_id
LEFT JOIN catalog.fao_standard fao_standard_id ON fao_standard_id.id = t.fao_standard_id
ORDER BY 2
);
END $function$
*/
}
/**
* @function data_lab_analysis_method_u
* @memberof zzglc
* @description Data lab analysis method u
* @param {character_varying} Json
* @returns {integer}
*/
function data_lab_analysis_method_u() {
/*
CREATE OR REPLACE FUNCTION zzglc.data_lab_analysis_method_u("Json" character varying)
RETURNS integer
LANGUAGE plpgsql
AS $function$
DECLARE v_id integer;
DECLARE json_data json;
BEGIN
json_data := "Json";
v_id := (json_data->>'id')::integer;
UPDATE data.lab_analysis_method SET
name = (json_data->>'name')::character varying,
usda_standard_id = (json_data->>'usda_standard_id')::integer,
fao_standard_id = (json_data->>'fao_standard_id')::integer
WHERE id = v_id;
RETURN v_id;
END $function$
*/
}
/**
* @function data_laboratory_c
* @memberof zzglc
* @description Data laboratory c
* @param {character_varying} Json
* @returns {integer}
*/
function data_laboratory_c() {
/*
CREATE OR REPLACE FUNCTION zzglc.data_laboratory_c("Json" character varying)
RETURNS integer
LANGUAGE plpgsql
AS $function$
DECLARE v_id integer;
DECLARE json_data json;
BEGIN
json_data := "Json";
INSERT INTO data.laboratory (name, address, country_id, url, contact)
VALUES ((json_data->>'name')::character varying, (json_data->>'address')::character varying, (json_data->>'country_id')::integer, (json_data->>'url')::character varying, (json_data->>'contact')::character varying)
RETURNING id INTO v_id;
RETURN v_id;
END $function$
*/
}
/**
* @function data_laboratory_d
* @memberof zzglc
* @description Data laboratory d
* @param {integer} Key
* @returns {void}
*/
function data_laboratory_d() {
/*
CREATE OR REPLACE FUNCTION zzglc.data_laboratory_d("Key" integer)
RETURNS void
LANGUAGE plpgsql
AS $function$
BEGIN
DELETE FROM data.laboratory WHERE id = "Key";
END;
$function$
*/
}
/**
* @function data_laboratory_r
* @memberof zzglc
* @description Data laboratory r
* @returns {Object} integer idcharacter_varying namecharacter_varying addressinteger general_country__country_idcharacter_varying urlcharacter_varying contactcharacter_varying general_country__country_id_val
*/
function data_laboratory_r() {
/*
CREATE OR REPLACE FUNCTION zzglc.data_laboratory_r()
RETURNS TABLE(id integer, name character varying, address character varying, general_country__country_id integer, url character varying, contact character varying, general_country__country_id_val character varying)
LANGUAGE plpgsql
AS $function$
BEGIN
RETURN QUERY (
SELECT t.id, t.name, t.address, t.country_id, t.url, t.contact, country_id.name
FROM data.laboratory t
LEFT JOIN general.country country_id ON country_id.id = t.country_id
ORDER BY 2
);
END $function$
*/
}
/**
* @function data_laboratory_u
* @memberof zzglc
* @description Data laboratory u
* @param {character_varying} Json
* @returns {void}
*/
function data_laboratory_u() {
/*
CREATE OR REPLACE FUNCTION zzglc.data_laboratory_u("Json" character varying)
RETURNS void
LANGUAGE plpgsql
AS $function$
DECLARE json_data json;
BEGIN
json_data := "Json";
UPDATE data.laboratory SET
name = (json_data->>'name')::character varying,
address = (json_data->>'address')::character varying,
country_id = (json_data->>'country_id')::integer,
url = (json_data->>'url')::character varying,
contact = (json_data->>'contact')::character varying
WHERE id = (json_data->>'id')::integer;
END $function$
*/
}
/**
* @function data_land_use_cover_c
* @memberof zzglc
* @description Data land use cover c
* @param {character_varying} Json
* @returns {integer}
*/
function data_land_use_cover_c() {
/*
CREATE OR REPLACE FUNCTION zzglc.data_land_use_cover_c("Json" character varying)
RETURNS integer
LANGUAGE plpgsql
AS $function$
DECLARE v_id integer;
DECLARE json_data json;
BEGIN
json_data := "Json";
INSERT INTO data.land_use_cover (point_id, land_usage_detail_id, protected, managed, organic_farming)
VALUES ((json_data->>'point_id')::integer, (json_data->>'land_usage_detail_id')::integer, (json_data->>'protected')::boolean, (json_data->>'managed')::boolean, (json_data->>'organic_farming')::boolean)
RETURNING id INTO v_id;
RETURN v_id;
END $function$
*/
}
/**
* @function data_land_use_cover_d
* @memberof zzglc
* @description Data land use cover d
* @param {integer} Key
* @returns {void}
*/
function data_land_use_cover_d() {
/*
CREATE OR REPLACE FUNCTION zzglc.data_land_use_cover_d("Key" integer)
RETURNS void
LANGUAGE plpgsql
AS $function$
BEGIN
DELETE FROM data.land_use_cover WHERE id = "Key";
END;
$function$
*/
}
/**
* @function data_land_use_cover_r
* @memberof zzglc
* @description Data land use cover r
* @param {integer} Key
* @returns {Object} integer idinteger data_point__point_idinteger land_usage_detail_idboolean protectedboolean managedboolean organic_farmingcharacter_varying data_point__point_id_val
*/
function data_land_use_cover_r() {
/*
CREATE OR REPLACE FUNCTION zzglc.data_land_use_cover_r("Key" integer)
RETURNS TABLE(id integer, data_point__point_id integer, land_usage_detail_id integer, protected boolean, managed boolean, organic_farming boolean, data_point__point_id_val character varying)
LANGUAGE plpgsql
AS $function$
BEGIN
RETURN QUERY (
SELECT t.id, t.point_id, t.land_usage_detail_id, t.protected, t.managed, t.organic_farming, point_id.point_key
FROM data.land_use_cover t
LEFT JOIN data.point point_id ON point_id.id = t.point_id
WHERE t.point_id = "Key"
ORDER BY 2
);
END $function$
*/
}
/**
* @function data_land_use_cover_r_overload
* @overload data_land_use_cover_r
* @memberof zzglc
* @description Data land use cover r
* @returns {Object} integer idinteger data_point__point_idinteger land_usage_detail_idboolean protectedboolean managedboolean organic_farmingcharacter_varying data_point__point_id_val
*/
function data_land_use_cover_r_overload() {
/*
CREATE OR REPLACE FUNCTION zzglc.data_land_use_cover_r()
RETURNS TABLE(id integer, data_point__point_id integer, land_usage_detail_id integer, protected boolean, managed boolean, organic_farming boolean, data_point__point_id_val character varying)
LANGUAGE plpgsql
AS $function$
BEGIN
RETURN QUERY (
SELECT t.id, t.point_id, t.land_usage_detail_id, t.protected, t.managed, t.organic_farming, point_id.point_key
FROM data.land_use_cover t
LEFT JOIN data.point point_id ON point_id.id = t.point_id
ORDER BY 2
);
END $function$
*/
}
/**
* @function data_land_use_cover_s_r
* @memberof zzglc
* @description Data land use cover s r
* @param {integer} Key
* @returns {Object} integer idinteger data_point__point_idinteger land_usage_detail_idboolean protectedboolean managedboolean organic_farmingcharacter_varying data_point__point_id_val
*/
function data_land_use_cover_s_r() {
/*
CREATE OR REPLACE FUNCTION zzglc.data_land_use_cover_s_r("Key" integer)
RETURNS TABLE(id integer, data_point__point_id integer, land_usage_detail_id integer, protected boolean, managed boolean, organic_farming boolean, data_point__point_id_val character varying)
LANGUAGE plpgsql
AS $function$
BEGIN
RETURN QUERY (
SELECT t.id, t.point_id, t.land_usage_detail_id, t.protected, t.managed, t.organic_farming, point_id.point_key
FROM data.land_use_cover t
LEFT JOIN data.point point_id ON point_id.id = t.point_id
WHERE t.id = "Key"
ORDER BY 2
);
END $function$
*/
}
/**
* @function data_land_use_cover_u
* @memberof zzglc
* @description Data land use cover u
* @param {character_varying} Json
* @returns {integer}
*/
function data_land_use_cover_u() {
/*
CREATE OR REPLACE FUNCTION zzglc.data_land_use_cover_u("Json" character varying)
RETURNS integer
LANGUAGE plpgsql
AS $function$
DECLARE v_id integer;
DECLARE json_data json;
BEGIN
json_data := "Json";
v_id := (json_data->>'id')::integer;
UPDATE data.land_use_cover SET
point_id = (json_data->>'point_id')::integer,
land_usage_detail_id = (json_data->>'land_usage_detail_id')::integer,
protected = (json_data->>'protected')::boolean,
managed = (json_data->>'managed')::boolean,
organic_farming = (json_data->>'organic_farming')::boolean
WHERE id = v_id;
RETURN v_id;
END $function$
*/
}
/**
* @function data_landscape_c
* @memberof zzglc
* @description Data landscape c
* @param {character_varying} Json
* @returns {integer}
*/
function data_landscape_c() {
/*
CREATE OR REPLACE FUNCTION zzglc.data_landscape_c("Json" character varying)
RETURNS integer
LANGUAGE plpgsql
AS $function$
DECLARE v_id integer;
DECLARE json_data json;
BEGIN
json_data := "Json";
INSERT INTO data.landscape (point_id, date_stamp, major_landform_id, hillslope_position_id, upward_slope, downward_slope, comment, person_id, distance_to_drainage_m)
VALUES ((json_data->>'point_id')::integer, (json_data->>'date_stamp')::date, (json_data->>'major_landform_id')::integer, (json_data->>'hillslope_position_id')::integer, (json_data->>'upward_slope')::smallint, (json_data->>'downward_slope')::smallint, (json_data->>'comment')::text, auth.get_context_person_id(), (json_data->>'distance_to_drainage_m')::smallint)
RETURNING id INTO v_id;
RETURN v_id;
END $function$
*/
}
/**
* @function data_landscape_d
* @memberof zzglc
* @description Data landscape d
* @param {integer} Key
* @returns {void}
*/
function data_landscape_d() {
/*
CREATE OR REPLACE FUNCTION zzglc.data_landscape_d("Key" integer)
RETURNS void
LANGUAGE plpgsql
AS $function$
BEGIN
DELETE FROM data.landscape WHERE id = "Key";
END;
$function$
*/
}
/**
* @function data_landscape_r
* @memberof zzglc
* @description Data landscape r
* @param {integer} Key
* @returns {Object} integer idinteger data_point__point_iddate date_stampinteger catalog_major_landform__major_landform_idinteger catalog_hillslope_position__hillslope_position_idsmallint upward_slopesmallint downward_slopetext commentinteger auth_person__person_idsmallint distance_to_drainage_mcharacter_varying data_point__point_id_valcharacter_varying catalog_major_landform__major_landform_id_valcharacter_varying catalog_hillslope_position__hillslope_position_id_valcharacter_varying auth_person__person_id_val
*/
function data_landscape_r() {
/*
CREATE OR REPLACE FUNCTION zzglc.data_landscape_r("Key" integer)
RETURNS TABLE(id integer, data_point__point_id integer, date_stamp date, catalog_major_landform__major_landform_id integer, catalog_hillslope_position__hillslope_position_id integer, upward_slope smallint, downward_slope smallint, comment text, auth_person__person_id integer, distance_to_drainage_m smallint, data_point__point_id_val character varying, catalog_major_landform__major_landform_id_val character varying, catalog_hillslope_position__hillslope_position_id_val character varying, auth_person__person_id_val character varying)
LANGUAGE plpgsql
AS $function$
BEGIN
RETURN QUERY (
SELECT t.id, t.point_id, t.date_stamp, t.major_landform_id, t.hillslope_position_id, t.upward_slope, t.downward_slope, t.comment, t.person_id, t.distance_to_drainage_m, point_id.point_key, major_landform_id.name, hillslope_position_id.name, person_id.email
FROM data.landscape t
LEFT JOIN auth.vw_partner vwp ON vwp.user_id = t.person_id AND vwp.partner_user_id = auth.get_context_person_id()
LEFT JOIN data.point point_id ON point_id.id = t.point_id
LEFT JOIN catalog.major_landform major_landform_id ON major_landform_id.id = t.major_landform_id
LEFT JOIN catalog.hillslope_position hillslope_position_id ON hillslope_position_id.id = t.hillslope_position_id
LEFT JOIN auth.person person_id ON person_id.id = t.person_id
WHERE t.point_id = "Key"
ORDER BY 2
);
END $function$
*/
}
/**
* @function data_landscape_r_overload
* @overload data_landscape_r
* @memberof zzglc
* @description Data landscape r
* @returns {Object} integer idinteger data_point__point_iddate date_stampinteger catalog_major_landform__major_landform_idinteger catalog_hillslope_position__hillslope_position_idsmallint upward_slopesmallint downward_slopetext commentinteger auth_person__person_idsmallint distance_to_drainage_mcharacter_varying data_point__point_id_valcharacter_varying catalog_major_landform__major_landform_id_valcharacter_varying catalog_hillslope_position__hillslope_position_id_valcharacter_varying auth_person__person_id_val
*/
function data_landscape_r_overload() {
/*
CREATE OR REPLACE FUNCTION zzglc.data_landscape_r()
RETURNS TABLE(id integer, data_point__point_id integer, date_stamp date, catalog_major_landform__major_landform_id integer, catalog_hillslope_position__hillslope_position_id integer, upward_slope smallint, downward_slope smallint, comment text, auth_person__person_id integer, distance_to_drainage_m smallint, data_point__point_id_val character varying, catalog_major_landform__major_landform_id_val character varying, catalog_hillslope_position__hillslope_position_id_val character varying, auth_person__person_id_val character varying)
LANGUAGE plpgsql
AS $function$
BEGIN
RETURN QUERY (
SELECT t.id, t.point_id, t.date_stamp, t.major_landform_id, t.hillslope_position_id, t.upward_slope, t.downward_slope, t.comment, t.person_id, t.distance_to_drainage_m, point_id.point_key, major_landform_id.name, hillslope_position_id.name, person_id.email
FROM data.landscape t
LEFT JOIN auth.vw_partner vwp ON vwp.user_id = t.person_id AND vwp.partner_user_id = auth.get_context_person_id()
LEFT JOIN data.point point_id ON point_id.id = t.point_id
LEFT JOIN catalog.major_landform major_landform_id ON major_landform_id.id = t.major_landform_id
LEFT JOIN catalog.hillslope_position hillslope_position_id ON hillslope_position_id.id = t.hillslope_position_id
LEFT JOIN auth.person person_id ON person_id.id = t.person_id
WHERE vwp.user_id = auth.get_context_person_id() OR auth.get_context_is_admin()
ORDER BY 2
);
END $function$
*/
}
/**
* @function data_landscape_u
* @memberof zzglc
* @description Data landscape u
* @param {character_varying} Json
* @returns {integer}
*/
function data_landscape_u() {
/*
CREATE OR REPLACE FUNCTION zzglc.data_landscape_u("Json" character varying)
RETURNS integer
LANGUAGE plpgsql
AS $function$
DECLARE v_id integer;
DECLARE json_data json;
BEGIN
json_data := "Json";
v_id := (json_data->>'id')::integer;
UPDATE data.landscape SET
point_id = (json_data->>'point_id')::integer,
date_stamp = (json_data->>'date_stamp')::date,
major_landform_id = (json_data->>'major_landform_id')::integer,
hillslope_position_id = (json_data->>'hillslope_position_id')::integer,
upward_slope = (json_data->>'upward_slope')::smallint,
downward_slope = (json_data->>'downward_slope')::smallint,
comment = (json_data->>'comment')::text,
person_id = (json_data->>'person_id')::integer,
distance_to_drainage_m = (json_data->>'distance_to_drainage_m')::smallint
WHERE id = v_id;
RETURN v_id;
END $function$
*/
}
/**
* @function data_lc_detail_c
* @memberof zzglc
* @description Data lc detail c
* @param {character_varying} Json
* @returns {void}
*/
function data_lc_detail_c() {
/*
CREATE OR REPLACE FUNCTION zzglc.data_lc_detail_c("Json" character varying)
RETURNS void
LANGUAGE plpgsql
AS $function$
BEGIN
INSERT INTO data.lc_detail (
name,
color_id,
code
)
SELECT
U.name,
U.color_id,
U.code
FROM
json_to_record("Json"::json) U (
name character varying,
color_id integer,
code character(3)
)
;
END $function$
*/
}
/**
* @function data_lc_detail_d
* @memberof zzglc
* @description Data lc detail d
* @param {integer} Key
* @returns {void}
*/
function data_lc_detail_d() {
/*
CREATE OR REPLACE FUNCTION zzglc.data_lc_detail_d("Key" integer)
RETURNS void
LANGUAGE plpgsql
AS $function$
BEGIN
DELETE FROM data.lc_detail
WHERE id = "Key";
END $function$
*/
}
/**
* @function data_lc_detail_r
* @memberof zzglc
* @description Data lc detail r
* @returns {Object}
* @property {integer} id
* @property {character_varying} name
* @property {integer} color_id
* @property {character} code
* @property {character_varying} color_id_val
* @property {character_varying} color_code
*/
function data_lc_detail_r() {
/*
CREATE OR REPLACE FUNCTION zzglc.data_lc_detail_r()
RETURNS TABLE(id integer, name character varying, general_color__color_id integer, code character, general_color__color_id_val character varying, color_code character varying)
LANGUAGE plpgsql
AS $function$
BEGIN
RETURN QUERY
SELECT
t.id, t.name, t.color_id, t.code
, color_id_t.name::VARCHAR AS color_id_val
, color_id_t.code
FROM data.lc_detail t
LEFT JOIN general.color color_id_t ON color_id_t.id = t.color_id
ORDER BY t.name
;
END $function$
*/
}
/**
* @function data_lc_detail_u
* @memberof zzglc
* @description Data lc detail u
* @param {character_varying} Json
* @returns {void}
*/
function data_lc_detail_u() {
/*
CREATE OR REPLACE FUNCTION zzglc.data_lc_detail_u("Json" character varying)
RETURNS void
LANGUAGE plpgsql
AS $function$
DECLARE v_row_count INTEGER;
BEGIN
UPDATE data.lc_detail t
SET name = U.name,
color_id = U.color_id,
code = U.code
FROM json_to_record("Json"::json) AS U (
id integer,
name character varying,
color_id integer,
code character(3)
)
WHERE U.id = t.id
;
END $function$
*/
}
/**
* @function data_lc_main_c
* @memberof zzglc
* @description Data lc main c
* @param {character_varying} Json
* @returns {void}
*/
function data_lc_main_c() {
/*
CREATE OR REPLACE FUNCTION zzglc.data_lc_main_c("Json" character varying)
RETURNS void
LANGUAGE plpgsql
AS $function$
BEGIN
INSERT INTO data.lc_main (
name,
color_id
)
SELECT
U.name,
U.color_id
FROM
json_to_record("Json"::json) U (
name character varying,
color_id integer
)
;
END $function$
*/
}
/**
* @function data_lc_main_d
* @memberof zzglc
* @description Data lc main d
* @param {integer} Key
* @returns {void}
*/
function data_lc_main_d() {
/*
CREATE OR REPLACE FUNCTION zzglc.data_lc_main_d("Key" integer)
RETURNS void
LANGUAGE plpgsql
AS $function$
BEGIN
DELETE FROM data.lc_main
WHERE id = "Key";
END $function$
*/
}
/**
* @function data_lc_main_r
* @memberof zzglc
* @description Data lc main r
* @returns {Object}
* @property {integer} id
* @property {character_varying} name
* @property {integer} color_id
* @property {character_varying} color_id_val
* @property {character_varying} color_code
*/
function data_lc_main_r() {
/*
CREATE OR REPLACE FUNCTION zzglc.data_lc_main_r()
RETURNS TABLE(id integer, name character varying, general_color__color_id integer, general_color__color_id_val character varying, color_code character varying)
LANGUAGE plpgsql
AS $function$
BEGIN
RETURN QUERY
SELECT
t.id, t.name, t.color_id
, color_id_t.name::VARCHAR AS color_id_val, color_id_t.code
FROM data.lc_main t
LEFT JOIN general.color color_id_t ON color_id_t.id = t.color_id
ORDER BY t.name
;
END $function$
*/
}
/**
* @function data_lc_main_u
* @memberof zzglc
* @description Data lc main u
* @param {character_varying} Json
* @returns {void}
*/
function data_lc_main_u() {
/*
CREATE OR REPLACE FUNCTION zzglc.data_lc_main_u("Json" character varying)
RETURNS void
LANGUAGE plpgsql
AS $function$
DECLARE v_row_count INTEGER;
BEGIN
UPDATE data.lc_main t
SET name = U.name,
color_id = U.color_id
FROM json_to_record("Json"::json) AS U (
id integer,
name character varying,
color_id integer
)
WHERE U.id = t.id
;
END $function$
*/
}
/**
* @function data_license_c
* @memberof zzglc
* @description Data license c
* @param {character_varying} Json
* @returns {void}
*/
function data_license_c() {
/*
CREATE OR REPLACE FUNCTION zzglc.data_license_c("Json" character varying)
RETURNS void
LANGUAGE plpgsql
AS $function$
BEGIN
INSERT INTO data.license (
name
)
SELECT
U.name
FROM
json_to_record("Json"::json) U (
name character varying
)
;
END $function$
*/
}
/**
* @function data_license_d
* @memberof zzglc
* @description Data license d
* @param {integer} Key
* @returns {void}
*/
function data_license_d() {
/*
CREATE OR REPLACE FUNCTION zzglc.data_license_d("Key" integer)
RETURNS void
LANGUAGE plpgsql
AS $function$
BEGIN
DELETE FROM data.license
WHERE id = "Key";
END $function$
*/
}
/**
* @function data_license_r
* @memberof zzglc
* @description Data license r
* @returns {Object}
* @property {integer} id
* @property {character_varying} name
*/
function data_license_r() {
/*
CREATE OR REPLACE FUNCTION zzglc.data_license_r()
RETURNS TABLE(id integer, name character varying)
LANGUAGE plpgsql
AS $function$
BEGIN
RETURN QUERY
SELECT
t.id, t.name
FROM data.license t
;
END $function$
*/
}
/**
* @function data_license_u
* @memberof zzglc
* @description Data license u
* @param {character_varying} Json
* @returns {void}
*/
function data_license_u() {
/*
CREATE OR REPLACE FUNCTION zzglc.data_license_u("Json" character varying)
RETURNS void
LANGUAGE plpgsql
AS $function$
DECLARE v_row_count INTEGER;
BEGIN
UPDATE data.license t
SET name = U.name
FROM json_to_record("Json"::json) AS U (
id integer,
name character varying
)
WHERE U.id = t.id
;
END $function$
*/
}
/**
* @function data_logistic_c
* @memberof zzglc
* @description Data logistic c
* @param {character_varying} Json
* @returns {integer}
*/
function data_logistic_c() {
/*
CREATE OR REPLACE FUNCTION zzglc.data_logistic_c("Json" character varying)
RETURNS integer
LANGUAGE plpgsql
AS $function$
DECLARE v_id integer;
DECLARE json_data json;
BEGIN
json_data := "Json";
INSERT INTO data.logistic (observation_id, preservation_id, transport_id, transport_duration_h, storage_id, storage_duration_h, person_id, observation_type_id)
VALUES ((json_data->>'observation_id')::integer, (json_data->>'preservation_id')::integer, (json_data->>'transport_id')::integer, (json_data->>'transport_duration_h')::smallint, (json_data->>'storage_id')::integer, (json_data->>'storage_duration_h')::smallint, auth.get_context_person_id(), (json_data->>'observation_type_id')::integer)
RETURNING id INTO v_id;
RETURN v_id;
END $function$
*/
}
/**
* @function data_logistic_d
* @memberof zzglc
* @description Data logistic d
* @param {integer} Key
* @returns {void}
*/
function data_logistic_d() {
/*
CREATE OR REPLACE FUNCTION zzglc.data_logistic_d("Key" integer)
RETURNS void
LANGUAGE plpgsql
AS $function$
BEGIN
DELETE FROM data.logistic WHERE id = "Key";
END;
$function$
*/
}
/**
* @function data_logistic_r
* @memberof zzglc
* @description Data logistic r
* @param {integer} Key
* @returns {Object} integer idinteger data_observation__observation_idinteger catalog_preservation__preservation_idinteger catalog_transport__transport_idsmallint transport_duration_hinteger catalog_storage__storage_idsmallint storage_duration_hinteger auth_person__person_idinteger catalog_observation_type__observation_type_idcharacter_varying data_observation__observation_id_valcharacter_varying catalog_preservation__preservation_id_valcharacter_varying catalog_transport__transport_id_valcharacter_varying catalog_storage__storage_id_valcharacter_varying auth_person__person_id_valcharacter_varying catalog_observation_type__observation_type_id_val
*/
function data_logistic_r() {
/*
CREATE OR REPLACE FUNCTION zzglc.data_logistic_r("Key" integer)
RETURNS TABLE(id integer, data_observation__observation_id integer, catalog_preservation__preservation_id integer, catalog_transport__transport_id integer, transport_duration_h smallint, catalog_storage__storage_id integer, storage_duration_h smallint, auth_person__person_id integer, catalog_observation_type__observation_type_id integer, data_observation__observation_id_val character varying, catalog_preservation__preservation_id_val character varying, catalog_transport__transport_id_val character varying, catalog_storage__storage_id_val character varying, auth_person__person_id_val character varying, catalog_observation_type__observation_type_id_val character varying)
LANGUAGE plpgsql
AS $function$
BEGIN
RETURN QUERY (
SELECT t.id, t.observation_id, t.preservation_id, t.transport_id, t.transport_duration_h, t.storage_id, t.storage_duration_h, t.person_id, t.observation_type_id, observation_id.comment, preservation_id.name, transport_id.name, storage_id.name, person_id.email, observation_type_id.name
FROM data.logistic t
LEFT JOIN auth.vw_partner vwp ON vwp.user_id = t.person_id AND vwp.partner_user_id = auth.get_context_person_id()
LEFT JOIN data.observation observation_id ON observation_id.id = t.observation_id
LEFT JOIN catalog.preservation preservation_id ON preservation_id.id = t.preservation_id
LEFT JOIN catalog.transport transport_id ON transport_id.id = t.transport_id
LEFT JOIN catalog.storage storage_id ON storage_id.id = t.storage_id
LEFT JOIN auth.person person_id ON person_id.id = t.person_id
LEFT JOIN catalog.observation_type observation_type_id ON observation_type_id.id = t.observation_type_id
WHERE t.observation_id = "Key"
ORDER BY 2
);
END $function$
*/
}
/**
* @function data_logistic_r_overload
* @overload data_logistic_r
* @memberof zzglc
* @description Data logistic r
* @returns {Object} integer idinteger data_observation__observation_idinteger catalog_preservation__preservation_idinteger catalog_transport__transport_idsmallint transport_duration_hinteger catalog_storage__storage_idsmallint storage_duration_hinteger auth_person__person_idinteger catalog_observation_type__observation_type_idcharacter_varying data_observation__observation_id_valcharacter_varying catalog_preservation__preservation_id_valcharacter_varying catalog_transport__transport_id_valcharacter_varying catalog_storage__storage_id_valcharacter_varying auth_person__person_id_valcharacter_varying catalog_observation_type__observation_type_id_val
*/
function data_logistic_r_overload() {
/*
CREATE OR REPLACE FUNCTION zzglc.data_logistic_r()
RETURNS TABLE(id integer, data_observation__observation_id integer, catalog_preservation__preservation_id integer, catalog_transport__transport_id integer, transport_duration_h smallint, catalog_storage__storage_id integer, storage_duration_h smallint, auth_person__person_id integer, catalog_observation_type__observation_type_id integer, data_observation__observation_id_val character varying, catalog_preservation__preservation_id_val character varying, catalog_transport__transport_id_val character varying, catalog_storage__storage_id_val character varying, auth_person__person_id_val character varying, catalog_observation_type__observation_type_id_val character varying)
LANGUAGE plpgsql
AS $function$
BEGIN
RETURN QUERY (
SELECT t.id, t.observation_id, t.preservation_id, t.transport_id, t.transport_duration_h, t.storage_id, t.storage_duration_h, t.person_id, t.observation_type_id, observation_id.comment, preservation_id.name, transport_id.name, storage_id.name, person_id.email, observation_type_id.name
FROM data.logistic t
LEFT JOIN auth.vw_partner vwp ON vwp.user_id = t.person_id AND vwp.partner_user_id = auth.get_context_person_id()
LEFT JOIN data.observation observation_id ON observation_id.id = t.observation_id
LEFT JOIN catalog.preservation preservation_id ON preservation_id.id = t.preservation_id
LEFT JOIN catalog.transport transport_id ON transport_id.id = t.transport_id
LEFT JOIN catalog.storage storage_id ON storage_id.id = t.storage_id
LEFT JOIN auth.person person_id ON person_id.id = t.person_id
LEFT JOIN catalog.observation_type observation_type_id ON observation_type_id.id = t.observation_type_id
WHERE vwp.user_id = auth.get_context_person_id() OR auth.get_context_is_admin()
ORDER BY 2
);
END $function$
*/
}
/**
* @function data_logistic_u
* @memberof zzglc
* @description Data logistic u
* @param {character_varying} Json
* @returns {integer}
*/
function data_logistic_u() {
/*
CREATE OR REPLACE FUNCTION zzglc.data_logistic_u("Json" character varying)
RETURNS integer
LANGUAGE plpgsql
AS $function$
DECLARE v_id integer;
DECLARE json_data json;
BEGIN
json_data := "Json";
v_id := (json_data->>'id')::integer;
UPDATE data.logistic SET
observation_id = (json_data->>'observation_id')::integer,
preservation_id = (json_data->>'preservation_id')::integer,
transport_id = (json_data->>'transport_id')::integer,
transport_duration_h = (json_data->>'transport_duration_h')::smallint,
storage_id = (json_data->>'storage_id')::integer,
storage_duration_h = (json_data->>'storage_duration_h')::smallint,
person_id = (json_data->>'person_id')::integer,
observation_type_id = (json_data->>'observation_type_id')::integer
WHERE id = v_id;
RETURN v_id;
END $function$
*/
}
/**
* @function data_lu_detail_c
* @memberof zzglc
* @description Data lu detail c
* @param {character_varying} Json
* @returns {void}
*/
function data_lu_detail_c() {
/*
CREATE OR REPLACE FUNCTION zzglc.data_lu_detail_c("Json" character varying)
RETURNS void
LANGUAGE plpgsql
AS $function$
BEGIN
INSERT INTO data.lu_detail (
name,
color_id,
code
)
SELECT
U.name,
U.color_id,
U.code
FROM
json_to_record("Json"::json) U (
name character varying,
color_id integer,
code character(4)
)
;
END $function$
*/
}
/**
* @function data_lu_detail_d
* @memberof zzglc
* @description Data lu detail d
* @param {integer} Key
* @returns {void}
*/
function data_lu_detail_d() {
/*
CREATE OR REPLACE FUNCTION zzglc.data_lu_detail_d("Key" integer)
RETURNS void
LANGUAGE plpgsql
AS $function$
BEGIN
DELETE FROM data.lu_detail
WHERE id = "Key";
END $function$
*/
}
/**
* @function data_lu_detail_r
* @memberof zzglc
* @description Data lu detail r
* @returns {Object}
* @property {integer} id
* @property {character_varying} name
* @property {character_varying} code
* @property {integer} color_id
* @property {character_varying} color_id_val
* @property {character_varying} color_code
*/
function data_lu_detail_r() {
/*
CREATE OR REPLACE FUNCTION zzglc.data_lu_detail_r()
RETURNS TABLE(id integer, name character varying, code character varying, general_color__color_id integer, general_color__color_id_val character varying, color_code character varying)
LANGUAGE plpgsql
AS $function$
BEGIN
RETURN QUERY
SELECT
t.id, t.name, t.code::VARCHAR, t.color_id
, color_id_t.name::VARCHAR AS color_id_val
, color_id_t.code
FROM data.lu_detail t
LEFT JOIN general.color color_id_t ON color_id_t.id = t.color_id
ORDER BY t.name
;
END $function$
*/
}
/**
* @function data_lu_detail_u
* @memberof zzglc
* @description Data lu detail u
* @param {character_varying} Json
* @returns {void}
*/
function data_lu_detail_u() {
/*
CREATE OR REPLACE FUNCTION zzglc.data_lu_detail_u("Json" character varying)
RETURNS void
LANGUAGE plpgsql
AS $function$
DECLARE v_row_count INTEGER;
BEGIN
UPDATE data.lu_detail t
SET name = U.name,
color_id = U.color_id,
code = U.code
FROM json_to_record("Json"::json) AS U (
id integer,
name character varying,
color_id integer,
code character(4)
)
WHERE U.id = t.id
;
END $function$
*/
}
/**
* @function data_macrofauna_c
* @memberof zzglc
* @description Data macrofauna c
* @param {character_varying} Json
* @returns {integer}
*/
function data_macrofauna_c() {
/*
CREATE OR REPLACE FUNCTION zzglc.data_macrofauna_c("Json" character varying)
RETURNS integer
LANGUAGE plpgsql
AS $function$
DECLARE v_id integer;
DECLARE json_data json;
BEGIN
json_data := "Json";
INSERT INTO data.macrofauna (observation_id, extraction_method_id, monolith_id, taxa_id, layer_id, life_cycle_stage_id, specimen_quantity, weight, monolith_top, monolith_bottom, person_id, excavation_tool_id)
VALUES ((json_data->>'observation_id')::integer, (json_data->>'extraction_method_id')::integer, (json_data->>'monolith_id')::integer, (json_data->>'taxa_id')::integer, (json_data->>'layer_id')::integer, (json_data->>'life_cycle_stage_id')::integer, (json_data->>'specimen_quantity')::integer, (json_data->>'weight')::double precision, (json_data->>'monolith_top')::integer, (json_data->>'monolith_bottom')::integer, auth.get_context_person_id(), (json_data->>'excavation_tool_id')::integer)
RETURNING id INTO v_id;
RETURN v_id;
END $function$
*/
}
/**
* @function data_macrofauna_d
* @memberof zzglc
* @description Data macrofauna d
* @param {integer} Key
* @returns {void}
*/
function data_macrofauna_d() {
/*
CREATE OR REPLACE FUNCTION zzglc.data_macrofauna_d("Key" integer)
RETURNS void
LANGUAGE plpgsql
AS $function$
BEGIN
DELETE FROM data.macrofauna WHERE id = "Key";
END;
$function$
*/
}
/**
* @function data_macrofauna_r
* @memberof zzglc
* @description Data macrofauna r
* @param {integer} Key
* @returns {Object} integer idinteger data_observation__observation_idinteger catalog_extraction_method__extraction_method_idinteger catalog_monolith__monolith_idinteger data_taxa__taxa_idinteger catalog_layer__layer_idinteger catalog_life_cycle_stage__life_cycle_stage_idinteger specimen_quantitydouble_precision weightinteger monolith_topinteger monolith_bottominteger auth_person__person_idinteger catalog_macrofauna_excavation_tool__excavation_tool_idcharacter_varying data_observation__observation_id_valcharacter_varying catalog_extraction_method__extraction_method_id_valcharacter_varying catalog_monolith__monolith_id_valcharacter_varying data_taxa__taxa_id_valcharacter_varying catalog_layer__layer_id_valcharacter_varying catalog_life_cycle_stage__life_cycle_stage_id_valcharacter_varying auth_person__person_id_valcharacter_varying catalog_macrofauna_excavation_tool__excavation_tool_id_val
*/
function data_macrofauna_r() {
/*
CREATE OR REPLACE FUNCTION zzglc.data_macrofauna_r("Key" integer)
RETURNS TABLE(id integer, data_observation__observation_id integer, catalog_extraction_method__extraction_method_id integer, catalog_monolith__monolith_id integer, data_taxa__taxa_id integer, catalog_layer__layer_id integer, catalog_life_cycle_stage__life_cycle_stage_id integer, specimen_quantity integer, weight double precision, monolith_top integer, monolith_bottom integer, auth_person__person_id integer, catalog_macrofauna_excavation_tool__excavation_tool_id integer, data_observation__observation_id_val character varying, catalog_extraction_method__extraction_method_id_val character varying, catalog_monolith__monolith_id_val character varying, data_taxa__taxa_id_val character varying, catalog_layer__layer_id_val character varying, catalog_life_cycle_stage__life_cycle_stage_id_val character varying, auth_person__person_id_val character varying, catalog_macrofauna_excavation_tool__excavation_tool_id_val character varying)
LANGUAGE plpgsql
AS $function$
BEGIN
RETURN QUERY (
SELECT t.id, t.observation_id, t.extraction_method_id, t.monolith_id, t.taxa_id, t.layer_id, t.life_cycle_stage_id, t.specimen_quantity, t.weight, t.monolith_top, t.monolith_bottom, t.person_id, t.excavation_tool_id, observation_id.comment, extraction_method_id.name, monolith_id.name, taxa_id.name, layer_id.name, life_cycle_stage_id.name, person_id.email, excavation_tool_id.name
FROM data.macrofauna t
LEFT JOIN auth.vw_partner vwp ON vwp.user_id = t.person_id AND vwp.partner_user_id = auth.get_context_person_id()
LEFT JOIN data.observation observation_id ON observation_id.id = t.observation_id
LEFT JOIN catalog.extraction_method extraction_method_id ON extraction_method_id.id = t.extraction_method_id
LEFT JOIN catalog.monolith monolith_id ON monolith_id.id = t.monolith_id
LEFT JOIN data.taxa taxa_id ON taxa_id.id = t.taxa_id
LEFT JOIN catalog.layer layer_id ON layer_id.id = t.layer_id
LEFT JOIN catalog.life_cycle_stage life_cycle_stage_id ON life_cycle_stage_id.id = t.life_cycle_stage_id
LEFT JOIN auth.person person_id ON person_id.id = t.person_id
LEFT JOIN catalog.macrofauna_excavation_tool excavation_tool_id ON excavation_tool_id.id = t.excavation_tool_id
WHERE t. observation_id = "Key"
ORDER BY 2
);
END $function$
*/
}
/**
* @function data_macrofauna_r_overload
* @overload data_macrofauna_r
* @memberof zzglc
* @description Data macrofauna r
* @returns {Object} integer idinteger data_observation__observation_idinteger catalog_extraction_method__extraction_method_idinteger catalog_monolith__monolith_idinteger data_taxa__taxa_idinteger catalog_layer__layer_idinteger catalog_life_cycle_stage__life_cycle_stage_idinteger specimen_quantitydouble_precision weightinteger monolith_topinteger monolith_bottominteger auth_person__person_idinteger catalog_macrofauna_excavation_tool__excavation_tool_idcharacter_varying data_observation__observation_id_valcharacter_varying catalog_extraction_method__extraction_method_id_valcharacter_varying catalog_monolith__monolith_id_valcharacter_varying data_taxa__taxa_id_valcharacter_varying catalog_layer__layer_id_valcharacter_varying catalog_life_cycle_stage__life_cycle_stage_id_valcharacter_varying auth_person__person_id_valcharacter_varying catalog_macrofauna_excavation_tool__excavation_tool_id_val
*/
function data_macrofauna_r_overload() {
/*
CREATE OR REPLACE FUNCTION zzglc.data_macrofauna_r()
RETURNS TABLE(id integer, data_observation__observation_id integer, catalog_extraction_method__extraction_method_id integer, catalog_monolith__monolith_id integer, data_taxa__taxa_id integer, catalog_layer__layer_id integer, catalog_life_cycle_stage__life_cycle_stage_id integer, specimen_quantity integer, weight double precision, monolith_top integer, monolith_bottom integer, auth_person__person_id integer, catalog_macrofauna_excavation_tool__excavation_tool_id integer, data_observation__observation_id_val character varying, catalog_extraction_method__extraction_method_id_val character varying, catalog_monolith__monolith_id_val character varying, data_taxa__taxa_id_val character varying, catalog_layer__layer_id_val character varying, catalog_life_cycle_stage__life_cycle_stage_id_val character varying, auth_person__person_id_val character varying, catalog_macrofauna_excavation_tool__excavation_tool_id_val character varying)
LANGUAGE plpgsql
AS $function$
BEGIN
RETURN QUERY (
SELECT t.id, t.observation_id, t.extraction_method_id, t.monolith_id, t.taxa_id, t.layer_id, t.life_cycle_stage_id, t.specimen_quantity, t.weight, t.monolith_top, t.monolith_bottom, t.person_id, t.excavation_tool_id, observation_id.comment, extraction_method_id.name, monolith_id.name, taxa_id.name, layer_id.name, life_cycle_stage_id.name, person_id.email, excavation_tool_id.name
FROM data.macrofauna t
LEFT JOIN auth.vw_partner vwp ON vwp.user_id = t.person_id AND vwp.partner_user_id = auth.get_context_person_id()
LEFT JOIN data.observation observation_id ON observation_id.id = t.observation_id
LEFT JOIN catalog.extraction_method extraction_method_id ON extraction_method_id.id = t.extraction_method_id
LEFT JOIN catalog.monolith monolith_id ON monolith_id.id = t.monolith_id
LEFT JOIN data.taxa taxa_id ON taxa_id.id = t.taxa_id
LEFT JOIN catalog.layer layer_id ON layer_id.id = t.layer_id
LEFT JOIN catalog.life_cycle_stage life_cycle_stage_id ON life_cycle_stage_id.id = t.life_cycle_stage_id
LEFT JOIN auth.person person_id ON person_id.id = t.person_id
LEFT JOIN catalog.macrofauna_excavation_tool excavation_tool_id ON excavation_tool_id.id = t.excavation_tool_id
WHERE vwp.user_id = auth.get_context_person_id() OR auth.get_context_is_admin()
ORDER BY 2
);
END $function$
*/
}
/**
* @function data_macrofauna_u
* @memberof zzglc
* @description Data macrofauna u
* @param {character_varying} Json
* @returns {integer}
*/
function data_macrofauna_u() {
/*
CREATE OR REPLACE FUNCTION zzglc.data_macrofauna_u("Json" character varying)
RETURNS integer
LANGUAGE plpgsql
AS $function$
DECLARE v_id integer;
DECLARE json_data json;
BEGIN
json_data := "Json";
v_id := (json_data->>'id')::integer;
UPDATE data.macrofauna SET
observation_id = (json_data->>'observation_id')::integer,
extraction_method_id = (json_data->>'extraction_method_id')::integer,
monolith_id = (json_data->>'monolith_id')::integer,
taxa_id = (json_data->>'taxa_id')::integer,
layer_id = (json_data->>'layer_id')::integer,
life_cycle_stage_id = (json_data->>'life_cycle_stage_id')::integer,
specimen_quantity = (json_data->>'specimen_quantity')::integer,
weight = (json_data->>'weight')::double precision,
monolith_top = (json_data->>'monolith_top')::integer,
monolith_bottom = (json_data->>'monolith_bottom')::integer,
person_id = (json_data->>'person_id')::integer,
excavation_tool_id = (json_data->>'excavation_tool_id')::integer
WHERE id = v_id;
RETURN v_id;
END $function$
*/
}
/**
* @function data_measurement_c
* @memberof zzglc
* @description Data measurement c
* @param {character_varying} Json
* @returns {void}
*/
function data_measurement_c() {
/*
CREATE OR REPLACE FUNCTION zzglc.data_measurement_c("Json" character varying)
RETURNS void
LANGUAGE plpgsql
AS $function$
BEGIN
INSERT INTO data.measurement (
indicator_id,
value,
point_id,
lod,
date,
data_source_id
)
SELECT
U.indicator_id,
U.value,
U.point_id,
U.lod,
U.date,
U.data_source_id
FROM
json_to_record("Json"::json) U (
indicator_id integer,
value real,
point_id integer,
lod character(1),
date date,
data_source_id integer
)
;
END $function$
*/
}
/**
* @function data_measurement_d
* @memberof zzglc
* @description Data measurement d
* @param {integer} Key
* @returns {void}
*/
function data_measurement_d() {
/*
CREATE OR REPLACE FUNCTION zzglc.data_measurement_d("Key" integer)
RETURNS void
LANGUAGE plpgsql
AS $function$
BEGIN
DELETE FROM data.measurement
WHERE id = "Key";
END $function$
*/
}
/**
* @function data_measurement_r
* @memberof zzglc
* @description Data measurement r
* @returns {Object}
* @property {integer} id
* @property {integer} indicator_id
* @property {real} value
* @property {integer} point_id
* @property {character} lod
* @property {date} date
* @property {integer} data_source_id
* @property {character_varying} indicator_id_val
* @property {character_varying} point_id_val
* @property {character_varying} data_source_id_val
*/
function data_measurement_r() {
/*
CREATE OR REPLACE FUNCTION zzglc.data_measurement_r()
RETURNS TABLE(id integer, indicator_id integer, value real, data_point__point_id integer, lod character, date date, data_data_source__data_source_id integer, indicator_id_val character varying, data_point__point_id_val character varying, data_data_source__data_source_id_val character varying)
LANGUAGE plpgsql
AS $function$
BEGIN
RETURN QUERY
SELECT
t.id, t.indicator_id, t.value, t.point_id, t.lod, t.date, t.data_source_id
, indicator_id_t.name::VARCHAR AS indicator_id_val, point_id_t.point_key::VARCHAR AS point_id_val, data_source_id_t.name::VARCHAR AS data_source_id_val
FROM data.measurement t
LEFT JOIN data.indicator indicator_id_t ON indicator_id_t.id = t.indicator_id
LEFT JOIN data.point point_id_t ON point_id_t.id = t.point_id
LEFT JOIN data.data_source data_source_id_t ON data_source_id_t.id = t.data_source_id
ORDER BY t.indicator_id
;
END $function$
*/
}
/**
* @function data_measurement_u
* @memberof zzglc
* @description Data measurement u
* @param {character_varying} Json
* @returns {void}
*/
function data_measurement_u() {
/*
CREATE OR REPLACE FUNCTION zzglc.data_measurement_u("Json" character varying)
RETURNS void
LANGUAGE plpgsql
AS $function$
DECLARE v_row_count INTEGER;
BEGIN
UPDATE data.measurement t
SET indicator_id = U.indicator_id,
value = U.value,
point_id = U.point_id,
lod = U.lod,
date = U.date,
data_source_id = U.data_source_id
FROM json_to_record("Json"::json) AS U (
id integer,
indicator_id integer,
value real,
point_id integer,
lod character(1),
date date,
data_source_id integer
)
WHERE U.id = t.id
;
END $function$
*/
}
/**
* @function data_method_transformation_c
* @memberof zzglc
* @description Data method transformation c
* @param {character_varying} Json
* @returns {integer}
*/
function data_method_transformation_c() {
/*
CREATE OR REPLACE FUNCTION zzglc.data_method_transformation_c("Json" character varying)
RETURNS integer
LANGUAGE plpgsql
AS $function$
DECLARE v_id integer;
DECLARE json_data json;
BEGIN
json_data := "Json";
INSERT INTO data.method_transformation (lab_analysis_method_from_id, lab_analysis_method_to_id, transformation)
VALUES ((json_data->>'lab_analysis_method_from_id')::integer, (json_data->>'lab_analysis_method_to_id')::integer, (json_data->>'transformation')::character varying)
RETURNING id INTO v_id;
RETURN v_id;
END $function$
*/
}
/**
* @function data_method_transformation_d
* @memberof zzglc
* @description Data method transformation d
* @param {integer} Key
* @returns {void}
*/
function data_method_transformation_d() {
/*
CREATE OR REPLACE FUNCTION zzglc.data_method_transformation_d("Key" integer)
RETURNS void
LANGUAGE plpgsql
AS $function$
BEGIN
DELETE FROM data.method_transformation WHERE id = "Key";
END;
$function$
*/
}
/**
* @function data_method_transformation_r
* @memberof zzglc
* @description Data method transformation r
* @param {integer} Key
* @returns {Object} integer idinteger data_lab_analysis_method__lab_analysis_method_from_idinteger data_lab_analysis_method__lab_analysis_method_to_idcharacter_varying transformationcharacter_varying data_lab_analysis_method__lab_analysis_method_from_id_valcharacter_varying data_lab_analysis_method__lab_analysis_method_to_id_val
*/
function data_method_transformation_r() {
/*
CREATE OR REPLACE FUNCTION zzglc.data_method_transformation_r("Key" integer)
RETURNS TABLE(id integer, data_lab_analysis_method__lab_analysis_method_from_id integer, data_lab_analysis_method__lab_analysis_method_to_id integer, transformation character varying, data_lab_analysis_method__lab_analysis_method_from_id_val character varying, data_lab_analysis_method__lab_analysis_method_to_id_val character varying)
LANGUAGE plpgsql
AS $function$
BEGIN
RETURN QUERY (
SELECT t.id, t.lab_analysis_method_from_id, t.lab_analysis_method_to_id, t.transformation, lab_analysis_method_from_id.name, lab_analysis_method_to_id.name
FROM data.method_transformation t
LEFT JOIN data.lab_analysis_method lab_analysis_method_from_id ON lab_analysis_method_from_id.id = t.lab_analysis_method_from_id
LEFT JOIN data.lab_analysis_method lab_analysis_method_to_id ON lab_analysis_method_to_id.id = t.lab_analysis_method_to_id
WHERE t.lab_analysis_method_from_id = "Key"
ORDER BY 2
);
END $function$
*/
}
/**
* @function data_method_transformation_r_overload
* @overload data_method_transformation_r
* @memberof zzglc
* @description Data method transformation r
* @returns {Object} integer idinteger data_lab_analysis_method__lab_analysis_method_from_idinteger data_lab_analysis_method__lab_analysis_method_to_idcharacter_varying transformationcharacter_varying data_lab_analysis_method__lab_analysis_method_from_id_valcharacter_varying data_lab_analysis_method__lab_analysis_method_to_id_val
*/
function data_method_transformation_r_overload() {
/*
CREATE OR REPLACE FUNCTION zzglc.data_method_transformation_r()
RETURNS TABLE(id integer, data_lab_analysis_method__lab_analysis_method_from_id integer, data_lab_analysis_method__lab_analysis_method_to_id integer, transformation character varying, data_lab_analysis_method__lab_analysis_method_from_id_val character varying, data_lab_analysis_method__lab_analysis_method_to_id_val character varying)
LANGUAGE plpgsql
AS $function$
BEGIN
RETURN QUERY (
SELECT t.id, t.lab_analysis_method_from_id, t.lab_analysis_method_to_id, t.transformation, lab_analysis_method_from_id.name, lab_analysis_method_to_id.name
FROM data.method_transformation t
LEFT JOIN data.lab_analysis_method lab_analysis_method_from_id ON lab_analysis_method_from_id.id = t.lab_analysis_method_from_id
LEFT JOIN data.lab_analysis_method lab_analysis_method_to_id ON lab_analysis_method_to_id.id = t.lab_analysis_method_to_id
ORDER BY 2
);
END $function$
*/
}
/**
* @function data_method_transformation_u
* @memberof zzglc
* @description Data method transformation u
* @param {character_varying} Json
* @returns {void}
*/
function data_method_transformation_u() {
/*
CREATE OR REPLACE FUNCTION zzglc.data_method_transformation_u("Json" character varying)
RETURNS void
LANGUAGE plpgsql
AS $function$
DECLARE json_data json;
BEGIN
json_data := "Json";
UPDATE data.method_transformation SET
lab_analysis_method_from_id = (json_data->>'lab_analysis_method_from_id')::integer,
lab_analysis_method_to_id = (json_data->>'lab_analysis_method_to_id')::integer,
transformation = (json_data->>'transformation')::character varying
WHERE id = (json_data->>'id')::integer;
END $function$
*/
}
/**
* @function data_microbiometer_c
* @memberof zzglc
* @description Data microbiometer c
* @param {character_varying} Json
* @returns {integer}
*/
function data_microbiometer_c() {
/*
CREATE OR REPLACE FUNCTION zzglc.data_microbiometer_c("Json" character varying)
RETURNS integer
LANGUAGE plpgsql
AS $function$
DECLARE v_id integer;
DECLARE json_data json;
BEGIN
json_data := "Json";
INSERT INTO data.microbiometer (carbon_content, fungi, bacteria, observation_id)
VALUES ((json_data->>'carbon_content')::double precision, (json_data->>'fungi')::smallint, (json_data->>'bacteria')::smallint, (json_data->>'observation_id')::integer)
RETURNING id INTO v_id;
RETURN v_id;
END $function$
*/
}
/**
* @function data_microbiometer_d
* @memberof zzglc
* @description Data microbiometer d
* @param {integer} Key
* @returns {void}
*/
function data_microbiometer_d() {
/*
CREATE OR REPLACE FUNCTION zzglc.data_microbiometer_d("Key" integer)
RETURNS void
LANGUAGE plpgsql
AS $function$
BEGIN
DELETE FROM data.microbiometer WHERE id = "Key";
END;
$function$
*/
}
/**
* @function data_microbiometer_r
* @memberof zzglc
* @description Data microbiometer r
* @param {integer} Key
* @returns {Object} integer iddouble_precision carbon_contentsmallint fungismallint bacteriainteger data_observation__observation_idcharacter_varying data_observation__observation_id_val
*/
function data_microbiometer_r() {
/*
CREATE OR REPLACE FUNCTION zzglc.data_microbiometer_r("Key" integer)
RETURNS TABLE(id integer, carbon_content double precision, fungi smallint, bacteria smallint, data_observation__observation_id integer, data_observation__observation_id_val character varying)
LANGUAGE plpgsql
AS $function$
BEGIN
RETURN QUERY (
SELECT t.id, t.carbon_content, t.fungi, t.bacteria, t.observation_id, observation_id.comment
FROM data.microbiometer t
LEFT JOIN data.observation observation_id ON observation_id.id = t.observation_id
WHERE t.observation_id = "Key"
ORDER BY 2
);
END $function$
*/
}
/**
* @function data_microbiometer_r_overload
* @overload data_microbiometer_r
* @memberof zzglc
* @description Data microbiometer r
* @returns {Object} integer iddouble_precision carbon_contentsmallint fungismallint bacteriainteger data_observation__observation_idcharacter_varying data_observation__observation_id_val
*/
function data_microbiometer_r_overload() {
/*
CREATE OR REPLACE FUNCTION zzglc.data_microbiometer_r()
RETURNS TABLE(id integer, carbon_content double precision, fungi smallint, bacteria smallint, data_observation__observation_id integer, data_observation__observation_id_val character varying)
LANGUAGE plpgsql
AS $function$
BEGIN
RETURN QUERY (
SELECT t.id, t.carbon_content, t.fungi, t.bacteria, t.observation_id, observation_id.comment
FROM data.microbiometer t
LEFT JOIN data.observation observation_id ON observation_id.id = t.observation_id
ORDER BY 2
);
END $function$
*/
}
/**
* @function data_microbiometer_u
* @memberof zzglc
* @description Data microbiometer u
* @param {character_varying} Json
* @returns {integer}
*/
function data_microbiometer_u() {
/*
CREATE OR REPLACE FUNCTION zzglc.data_microbiometer_u("Json" character varying)
RETURNS integer
LANGUAGE plpgsql
AS $function$
DECLARE v_id integer;
DECLARE json_data json;
BEGIN
json_data := "Json";
v_id := (json_data->>'id')::integer;
UPDATE data.microbiometer SET
carbon_content = (json_data->>'carbon_content')::double precision,
fungi = (json_data->>'fungi')::smallint,
bacteria = (json_data->>'bacteria')::smallint,
observation_id = (json_data->>'observation_id')::integer
WHERE id = v_id;
RETURN v_id;
END $function$
*/
}
/**
* @function data_nucleotide_archive_c
* @memberof zzglc
* @description Data nucleotide archive c
* @param {character_varying} Json
* @returns {integer}
*/
function data_nucleotide_archive_c() {
/*
CREATE OR REPLACE FUNCTION zzglc.data_nucleotide_archive_c("Json" character varying)
RETURNS integer
LANGUAGE plpgsql
AS $function$
DECLARE v_id integer;
DECLARE json_data json;
BEGIN
json_data := "Json";
INSERT INTO data.nucleotide_archive (database_name, proprietor_id, info, url)
VALUES ((json_data->>'database_name')::character varying, (json_data->>'proprietor_id')::integer, (json_data->>'info')::character varying, (json_data->>'url')::character varying)
RETURNING id INTO v_id;
RETURN v_id;
END $function$
*/
}
/**
* @function data_nucleotide_archive_d
* @memberof zzglc
* @description Data nucleotide archive d
* @param {integer} Key
* @returns {void}
*/
function data_nucleotide_archive_d() {
/*
CREATE OR REPLACE FUNCTION zzglc.data_nucleotide_archive_d("Key" integer)
RETURNS void
LANGUAGE plpgsql
AS $function$
BEGIN
DELETE FROM data.nucleotide_archive WHERE id = "Key";
END;
$function$
*/
}
/**
* @function data_nucleotide_archive_r
* @memberof zzglc
* @description Data nucleotide archive r
* @returns {Object} integer idcharacter_varying database_nameinteger catalog_proprietor__proprietor_idcharacter_varying infocharacter_varying urlcharacter_varying catalog_proprietor__proprietor_id_val
*/
function data_nucleotide_archive_r() {
/*
CREATE OR REPLACE FUNCTION zzglc.data_nucleotide_archive_r()
RETURNS TABLE(id integer, database_name character varying, catalog_proprietor__proprietor_id integer, info character varying, url character varying, catalog_proprietor__proprietor_id_val character varying)
LANGUAGE plpgsql
AS $function$
BEGIN
RETURN QUERY (
SELECT t.id, t.database_name, t.proprietor_id, t.info, t.url, proprietor_id.name
FROM data.nucleotide_archive t
LEFT JOIN catalog.proprietor proprietor_id ON proprietor_id.id = t.proprietor_id
ORDER BY 2
);
END $function$
*/
}
/**
* @function data_nucleotide_archive_u
* @memberof zzglc
* @description Data nucleotide archive u
* @param {character_varying} Json
* @returns {integer}
*/
function data_nucleotide_archive_u() {
/*
CREATE OR REPLACE FUNCTION zzglc.data_nucleotide_archive_u("Json" character varying)
RETURNS integer
LANGUAGE plpgsql
AS $function$
DECLARE v_id integer;
DECLARE json_data json;
BEGIN
json_data := "Json";
v_id := (json_data->>'id')::integer;
UPDATE data.nucleotide_archive SET
database_name = (json_data->>'database_name')::character varying,
proprietor_id = (json_data->>'proprietor_id')::integer,
info = (json_data->>'info')::character varying,
url = (json_data->>'url')::character varying
WHERE id = v_id;
RETURN v_id;
END $function$
*/
}
/**
* @function data_observation_c
* @memberof zzglc
* @description Data observation c
* @param {character_varying} Json
* @returns {integer}
*/
function data_observation_c() {
/*
CREATE OR REPLACE FUNCTION zzglc.data_observation_c("Json" character varying)
RETURNS integer
LANGUAGE plpgsql
AS $function$
DECLARE v_id integer;
DECLARE json_data json;
BEGIN
json_data := "Json";
INSERT INTO data.observation (sample_id, subsample, repeat, person_id, equipment_id, laboratory_id, comment, sample_preparation_id, date_stamp, observation_type_id)
VALUES ((json_data->>'sample_id')::integer, (json_data->>'subsample')::character varying, (json_data->>'repeat')::smallint, auth.get_context_person_id(), (json_data->>'equipment_id')::integer, (json_data->>'laboratory_id')::integer, (json_data->>'comment')::character varying, (json_data->>'sample_preparation_id')::integer, (json_data->>'date_stamp')::timestamp with time zone, (json_data->>'observation_type_id')::integer)
RETURNING id INTO v_id;
RETURN v_id;
END $function$
*/
}
/**
* @function data_observation_d
* @memberof zzglc
* @description Data observation d
* @param {integer} Key
* @returns {void}
*/
function data_observation_d() {
/*
CREATE OR REPLACE FUNCTION zzglc.data_observation_d("Key" integer)
RETURNS void
LANGUAGE plpgsql
AS $function$
BEGIN
DELETE FROM data.observation WHERE id = "Key";
END;
$function$
*/
}
/**
* @function data_observation_measurement_c
* @memberof zzglc
* @description Data observation measurement c
* @param {character_varying} Json
* @returns {integer}
*/
function data_observation_measurement_c() {
/*
CREATE OR REPLACE FUNCTION zzglc.data_observation_measurement_c("Json" character varying)
RETURNS integer
LANGUAGE plpgsql
AS $function$
DECLARE v_id integer;
DECLARE json_data json;
BEGIN
json_data := "Json";
INSERT INTO data.observation_measurement (observation_id, indicator_id, value, std_dev, lab_analysis_method_id, date_stamp, person_id, unit_id)
VALUES ((json_data->>'observation_id')::integer, (json_data->>'indicator_id')::integer, (json_data->>'value')::real, (json_data->>'std_dev')::real, (json_data->>'lab_analysis_method_id')::integer, (json_data->>'date_stamp')::timestamp with time zone, auth.get_context_person_id(), (json_data->>'unit_id')::integer)
RETURNING id INTO v_id;
RETURN v_id;
END $function$
*/
}
/**
* @function data_observation_measurement_d
* @memberof zzglc
* @description Data observation measurement d
* @param {integer} Key
* @returns {void}
*/
function data_observation_measurement_d() {
/*
CREATE OR REPLACE FUNCTION zzglc.data_observation_measurement_d("Key" integer)
RETURNS void
LANGUAGE plpgsql
AS $function$
BEGIN
DELETE FROM data.observation_measurement WHERE id = "Key";
END;
$function$
*/
}
/**
* @function data_observation_measurement_r
* @memberof zzglc
* @description Data observation measurement r
* @param {integer} Key
* @returns {Object} integer idinteger data_observation__observation_idinteger data_indicator__indicator_idreal valuereal std_devinteger data_lab_analysis_method__lab_analysis_method_idtimestamp_with_time_zone date_stampinteger auth_person__person_idinteger catalog_unit__unit_idcharacter_varying data_observation__observation_id_valcharacter_varying data_indicator__indicator_id_valcharacter_varying data_lab_analysis_method__lab_analysis_method_id_valcharacter_varying auth_person__person_id_valcharacter_varying catalog_unit__unit_id_val
*/
function data_observation_measurement_r() {
/*
CREATE OR REPLACE FUNCTION zzglc.data_observation_measurement_r("Key" integer)
RETURNS TABLE(id integer, data_observation__observation_id integer, data_indicator__indicator_id integer, value real, std_dev real, data_lab_analysis_method__lab_analysis_method_id integer, date_stamp timestamp with time zone, auth_person__person_id integer, catalog_unit__unit_id integer, data_observation__observation_id_val character varying, data_indicator__indicator_id_val character varying, data_lab_analysis_method__lab_analysis_method_id_val character varying, auth_person__person_id_val character varying, catalog_unit__unit_id_val character varying)
LANGUAGE plpgsql
AS $function$
BEGIN
RETURN QUERY (
SELECT t.id, t.observation_id, t.indicator_id, t.value, t.std_dev, t.lab_analysis_method_id, t.date_stamp, t.person_id, t.unit_id, observation_id.comment, indicator_id.display_name, lab_analysis_method_id.name, person_id.email, unit_id.display_name
FROM data.observation_measurement t
LEFT JOIN auth.vw_partner vwp ON vwp.user_id = t.person_id AND vwp.partner_user_id = auth.get_context_person_id()
LEFT JOIN data.observation observation_id ON observation_id.id = t.observation_id
LEFT JOIN data.indicator indicator_id ON indicator_id.id = t.indicator_id
LEFT JOIN data.lab_analysis_method lab_analysis_method_id ON lab_analysis_method_id.id = t.lab_analysis_method_id
LEFT JOIN auth.person person_id ON person_id.id = t.person_id
LEFT JOIN catalog.unit unit_id ON unit_id.id = t.unit_id
WHERE t.observation_id = "Key"
ORDER BY 2
);
END $function$
*/
}
/**
* @function data_observation_measurement_r_overload
* @overload data_observation_measurement_r
* @memberof zzglc
* @description Data observation measurement r
* @returns {Object} integer idinteger data_observation__observation_idinteger data_indicator__indicator_idreal valuereal std_devinteger data_lab_analysis_method__lab_analysis_method_idtimestamp_with_time_zone date_stampinteger auth_person__person_idinteger catalog_unit__unit_idcharacter_varying data_observation__observation_id_valcharacter_varying data_indicator__indicator_id_valcharacter_varying data_lab_analysis_method__lab_analysis_method_id_valcharacter_varying auth_person__person_id_valcharacter_varying catalog_unit__unit_id_val
*/
function data_observation_measurement_r_overload() {
/*
CREATE OR REPLACE FUNCTION zzglc.data_observation_measurement_r()
RETURNS TABLE(id integer, data_observation__observation_id integer, data_indicator__indicator_id integer, value real, std_dev real, data_lab_analysis_method__lab_analysis_method_id integer, date_stamp timestamp with time zone, auth_person__person_id integer, catalog_unit__unit_id integer, data_observation__observation_id_val character varying, data_indicator__indicator_id_val character varying, data_lab_analysis_method__lab_analysis_method_id_val character varying, auth_person__person_id_val character varying, catalog_unit__unit_id_val character varying)
LANGUAGE plpgsql
AS $function$
BEGIN
RETURN QUERY (
SELECT t.id, t.observation_id, t.indicator_id, t.value, t.std_dev, t.lab_analysis_method_id, t.date_stamp, t.person_id, t.unit_id, observation_id.comment, indicator_id.display_name, lab_analysis_method_id.name, person_id.email, unit_id.display_name
FROM data.observation_measurement t
LEFT JOIN auth.vw_partner vwp ON vwp.user_id = t.person_id AND vwp.partner_user_id = auth.get_context_person_id()
LEFT JOIN data.observation observation_id ON observation_id.id = t.observation_id
LEFT JOIN data.indicator indicator_id ON indicator_id.id = t.indicator_id
LEFT JOIN data.lab_analysis_method lab_analysis_method_id ON lab_analysis_method_id.id = t.lab_analysis_method_id
LEFT JOIN auth.person person_id ON person_id.id = t.person_id
LEFT JOIN catalog.unit unit_id ON unit_id.id = t.unit_id
WHERE vwp.user_id = auth.get_context_person_id() OR auth.get_context_is_admin()
ORDER BY 2
);
END $function$
*/
}
/**
* @function data_observation_measurement_u
* @memberof zzglc
* @description Data observation measurement u
* @param {character_varying} Json
* @returns {integer}
*/
function data_observation_measurement_u() {
/*
CREATE OR REPLACE FUNCTION zzglc.data_observation_measurement_u("Json" character varying)
RETURNS integer
LANGUAGE plpgsql
AS $function$
DECLARE v_id integer;
DECLARE json_data json;
BEGIN
json_data := "Json";
v_id := (json_data->>'id')::integer;
UPDATE data.observation_measurement SET
observation_id = (json_data->>'observation_id')::integer,
indicator_id = (json_data->>'indicator_id')::integer,
value = (json_data->>'value')::real,
std_dev = (json_data->>'std_dev')::real,
lab_analysis_method_id = (json_data->>'lab_analysis_method_id')::integer,
date_stamp = (json_data->>'date_stamp')::timestamp with time zone,
person_id = (json_data->>'person_id')::integer,
unit_id = (json_data->>'unit_id')::integer
WHERE id = v_id;
RETURN v_id;
END $function$
*/
}
/**
* @function data_observation_r
* @memberof zzglc
* @description Data observation r
* @param {integer} Key
* @returns {Object} integer idinteger data_sample__sample_idcharacter_varying subsamplesmallint repeatinteger auth_person__person_idinteger data_equipment__equipment_idinteger data_laboratory__laboratory_idcharacter_varying commentinteger catalog_sample_preparation__sample_preparation_idtimestamp_with_time_zone date_stampcharacter_varying data_sample__sample_id_valcharacter_varying auth_person__person_id_valcharacter_varying data_equipment__equipment_id_valcharacter_varying data_laboratory__laboratory_id_valcharacter_varying catalog_sample_preparation__sample_preparation_id_val
*/
function data_observation_r() {
/*
CREATE OR REPLACE FUNCTION zzglc.data_observation_r("Key" integer)
RETURNS TABLE(id integer, data_sample__sample_id integer, subsample character varying, repeat smallint, auth_person__person_id integer, data_equipment__equipment_id integer, data_laboratory__laboratory_id integer, comment character varying, catalog_sample_preparation__sample_preparation_id integer, date_stamp timestamp with time zone, data_sample__sample_id_val character varying, auth_person__person_id_val character varying, data_equipment__equipment_id_val character varying, data_laboratory__laboratory_id_val character varying, catalog_sample_preparation__sample_preparation_id_val character varying)
LANGUAGE plpgsql
AS $function$
BEGIN
RETURN QUERY (
SELECT t.id, t.sample_id, t.subsample, t.repeat, t.person_id, t.equipment_id, t.laboratory_id, t.comment, t.sample_preparation_id, t.date_stamp, sample_id.name, person_id.email, equipment_id.model, laboratory_id.name, sample_preparation_id.name
FROM data.observation t
LEFT JOIN auth.vw_partner vwp ON vwp.user_id = t.person_id AND vwp.partner_user_id = auth.get_context_person_id()
LEFT JOIN data.sample sample_id ON sample_id.id = t.sample_id
LEFT JOIN auth.person person_id ON person_id.id = t.person_id
LEFT JOIN data.equipment equipment_id ON equipment_id.id = t.equipment_id
LEFT JOIN data.laboratory laboratory_id ON laboratory_id.id = t.laboratory_id
LEFT JOIN catalog.sample_preparation sample_preparation_id ON sample_preparation_id.id = t.sample_preparation_id
WHERE t.sample_id = "Key"
ORDER BY 2
);
END $function$
*/
}
/**
* @function data_observation_r_overload
* @overload data_observation_r
* @memberof zzglc
* @description Data observation r
* @returns {Object} integer idinteger data_sample__sample_idcharacter_varying subsamplesmallint repeatinteger auth_person__person_idinteger data_equipment__equipment_idinteger data_laboratory__laboratory_idcharacter_varying commentinteger catalog_sample_preparation__sample_preparation_idtimestamp_with_time_zone date_stampinteger catalog_observation_type__observation_type_idcharacter_varying data_sample__sample_id_valcharacter_varying auth_person__person_id_valcharacter_varying data_equipment__equipment_id_valcharacter_varying data_laboratory__laboratory_id_valcharacter_varying catalog_sample_preparation__sample_preparation_id_valcharacter_varying catalog_observation_type__observation_type_id_val
*/
function data_observation_r_overload() {
/*
CREATE OR REPLACE FUNCTION zzglc.data_observation_r()
RETURNS TABLE(id integer, data_sample__sample_id integer, subsample character varying, repeat smallint, auth_person__person_id integer, data_equipment__equipment_id integer, data_laboratory__laboratory_id integer, comment character varying, catalog_sample_preparation__sample_preparation_id integer, date_stamp timestamp with time zone, catalog_observation_type__observation_type_id integer, data_sample__sample_id_val character varying, auth_person__person_id_val character varying, data_equipment__equipment_id_val character varying, data_laboratory__laboratory_id_val character varying, catalog_sample_preparation__sample_preparation_id_val character varying, catalog_observation_type__observation_type_id_val character varying)
LANGUAGE plpgsql
AS $function$
BEGIN
RETURN QUERY (
SELECT t.id, t.sample_id, t.subsample, t.repeat, t.person_id, t.equipment_id, t.laboratory_id, t.comment, t.sample_preparation_id, t.date_stamp, t.observation_type_id, sample_id.name, person_id.email, equipment_id.model, laboratory_id.name, sample_preparation_id.name, observation_type_id.name
FROM data.observation t
LEFT JOIN auth.vw_partner vwp ON vwp.user_id = t.person_id AND vwp.partner_user_id = auth.get_context_person_id()
LEFT JOIN data.sample sample_id ON sample_id.id = t.sample_id
LEFT JOIN auth.person person_id ON person_id.id = t.person_id
LEFT JOIN data.equipment equipment_id ON equipment_id.id = t.equipment_id
LEFT JOIN data.laboratory laboratory_id ON laboratory_id.id = t.laboratory_id
LEFT JOIN catalog.sample_preparation sample_preparation_id ON sample_preparation_id.id = t.sample_preparation_id
LEFT JOIN catalog.observation_type observation_type_id ON observation_type_id.id = t.observation_type_id
WHERE vwp.user_id = auth.get_context_person_id() OR auth.get_context_is_admin()
ORDER BY 2
);
END $function$
*/
}
/**
* @function data_observation_u
* @memberof zzglc
* @description Data observation u
* @param {character_varying} Json
* @returns {integer}
*/
function data_observation_u() {
/*
CREATE OR REPLACE FUNCTION zzglc.data_observation_u("Json" character varying)
RETURNS integer
LANGUAGE plpgsql
AS $function$
DECLARE v_id integer;
DECLARE json_data json;
BEGIN
json_data := "Json";
v_id := (json_data->>'id')::integer;
UPDATE data.observation SET
sample_id = (json_data->>'sample_id')::integer,
subsample = (json_data->>'subsample')::character varying,
repeat = (json_data->>'repeat')::smallint,
person_id = (json_data->>'person_id')::integer,
equipment_id = (json_data->>'equipment_id')::integer,
laboratory_id = (json_data->>'laboratory_id')::integer,
comment = (json_data->>'comment')::character varying,
sample_preparation_id = (json_data->>'sample_preparation_id')::integer,
date_stamp = (json_data->>'date_stamp')::timestamp with time zone,
observation_type_id = (json_data->>'observation_type_id')::integer
WHERE id = v_id;
RETURN v_id;
END $function$
*/
}
/**
* @function data_oedce_c
* @memberof zzglc
* @description Data oedce c
* @param {character_varying} Json
* @returns {void}
*/
function data_oedce_c() {
/*
CREATE OR REPLACE FUNCTION zzglc.data_oedce_c("Json" character varying)
RETURNS void
LANGUAGE plpgsql
AS $function$
BEGIN
INSERT INTO data.oedce (
start_datetime,
end_datetime,
gsd,
instruments,
datetime,
item_id,
item_bbox,
href,
type,
main,
roles,
asset_id,
collection_id,
collection_title,
collection_description,
collection_providers,
collection_keywords,
collection_license,
platform,
geom
)
SELECT
U.start_datetime,
U.end_datetime,
U.gsd,
U.instruments,
U.datetime,
U.item_id,
U.item_bbox,
U.href,
U.type,
U.main,
U.roles,
U.asset_id,
U.collection_id,
U.collection_title,
U.collection_description,
U.collection_providers,
U.collection_keywords,
U.collection_license,
U.platform,
U.geom
FROM
json_to_record("Json"::json) U (
start_datetime character varying,
end_datetime character varying,
gsd character varying,
instruments character varying,
datetime character varying,
item_id character varying,
item_bbox character varying,
href character varying,
type character varying,
main character varying,
roles character varying,
asset_id character varying,
collection_id character varying,
collection_title character varying,
collection_description character varying,
collection_providers character varying,
collection_keywords character varying,
collection_license character varying,
platform character varying,
geom geometry
)
;
END $function$
*/
}
/**
* @function data_oedce_d
* @memberof zzglc
* @description Data oedce d
* @param {integer} Key
* @returns {void}
*/
function data_oedce_d() {
/*
CREATE OR REPLACE FUNCTION zzglc.data_oedce_d("Key" integer)
RETURNS void
LANGUAGE plpgsql
AS $function$
BEGIN
DELETE FROM data.oedce
WHERE fid = "Key";
END $function$
*/
}
/**
* @function data_oedce_r
* @memberof zzglc
* @description Data oedce r
* @returns {Object}
* @property {integer} fid
* @property {character_varying} start_datetime
* @property {character_varying} end_datetime
* @property {character_varying} gsd
* @property {character_varying} instruments
* @property {character_varying} datetime
* @property {character_varying} item_id
* @property {character_varying} item_bbox
* @property {character_varying} href
* @property {character_varying} type
* @property {character_varying} main
* @property {character_varying} roles
* @property {character_varying} asset_id
* @property {character_varying} collection_id
* @property {character_varying} collection_title
* @property {character_varying} collection_description
* @property {character_varying} collection_providers
* @property {character_varying} collection_keywords
* @property {character_varying} collection_license
* @property {character_varying} platform
*/
function data_oedce_r() {
/*
CREATE OR REPLACE FUNCTION zzglc.data_oedce_r()
RETURNS TABLE(fid integer, start_datetime character varying, end_datetime character varying, gsd character varying, instruments character varying, datetime character varying, item_id character varying, item_bbox character varying, href character varying, type character varying, main character varying, roles character varying, asset_id character varying, collection_id character varying, collection_title character varying, collection_description character varying, collection_providers character varying, collection_keywords character varying, collection_license character varying, platform character varying)
LANGUAGE plpgsql
AS $function$
BEGIN
RETURN QUERY
SELECT
t.fid, t.start_datetime, t.end_datetime, t.gsd, t.instruments, t.datetime, t.item_id, t.item_bbox, t.href, t.type, t.main, t.roles, t.asset_id, t.collection_id, t.collection_title, t.collection_description, t.collection_providers, t.collection_keywords, t.collection_license, t.platform
FROM data.oedce t
;
END $function$
*/
}
/**
* @function data_oedce_u
* @memberof zzglc
* @description Data oedce u
* @param {character_varying} Json
* @returns {void}
*/
function data_oedce_u() {
/*
CREATE OR REPLACE FUNCTION zzglc.data_oedce_u("Json" character varying)
RETURNS void
LANGUAGE plpgsql
AS $function$
DECLARE v_row_count INTEGER;
BEGIN
UPDATE data.oedce t
SET start_datetime = U.start_datetime,
end_datetime = U.end_datetime,
gsd = U.gsd,
instruments = U.instruments,
datetime = U.datetime,
item_id = U.item_id,
item_bbox = U.item_bbox,
href = U.href,
type = U.type,
main = U.main,
roles = U.roles,
asset_id = U.asset_id,
collection_id = U.collection_id,
collection_title = U.collection_title,
collection_description = U.collection_description,
collection_providers = U.collection_providers,
collection_keywords = U.collection_keywords,
collection_license = U.collection_license,
platform = U.platform,
geom = U.geom
FROM json_to_record("Json"::json) AS U (
fid integer,
start_datetime character varying,
end_datetime character varying,
gsd character varying,
instruments character varying,
datetime character varying,
item_id character varying,
item_bbox character varying,
href character varying,
type character varying,
main character varying,
roles character varying,
asset_id character varying,
collection_id character varying,
collection_title character varying,
collection_description character varying,
collection_providers character varying,
collection_keywords character varying,
collection_license character varying,
platform character varying,
geom geometry(Polygon,900914)
)
WHERE U.fid = t.fid
;
END $function$
*/
}
/**
* @function data_pilot_c
* @memberof zzglc
* @description Data pilot c
* @param {character_varying} Json
* @returns {integer}
*/
function data_pilot_c() {
/*
CREATE OR REPLACE FUNCTION zzglc.data_pilot_c("Json" character varying)
RETURNS integer
LANGUAGE plpgsql
AS $function$
DECLARE v_id integer;
DECLARE json_data json;
BEGIN
json_data := "Json";
INSERT INTO data.pilot (name, country_id, contact_person_id, person_id, description, url, ai4soilhealth_pilot)
VALUES ((json_data->>'name')::character varying, (json_data->>'country_id')::integer, (json_data->>'contact_person_id')::integer, (json_data->>'person_id')::integer, (json_data->>'description')::text, (json_data->>'url')::character varying, (json_data->>'ai4soilhealth_pilot')::boolean)
RETURNING id INTO v_id;
RETURN v_id;
END $function$
*/
}
/**
* @function data_pilot_d
* @memberof zzglc
* @description Data pilot d
* @param {integer} Key
* @returns {void}
*/
function data_pilot_d() {
/*
CREATE OR REPLACE FUNCTION zzglc.data_pilot_d("Key" integer)
RETURNS void
LANGUAGE plpgsql
AS $function$
BEGIN
DELETE FROM data.pilot WHERE id = "Key";
END;
$function$
*/
}
/**
* @function data_pilot_r
* @memberof zzglc
* @description Data pilot r
* @returns {Object} integer idcharacter_varying nameinteger general_country__country_idinteger auth_person__contact_person_idinteger auth_person__person_idtext descriptioncharacter_varying urlboolean ai4soilhealth_pilotcharacter_varying general_country__country_id_valcharacter_varying auth_person__contact_person_id_valcharacter_varying auth_person__person_id_val
*/
function data_pilot_r() {
/*
CREATE OR REPLACE FUNCTION zzglc.data_pilot_r()
RETURNS TABLE(id integer, name character varying, general_country__country_id integer, auth_person__contact_person_id integer, auth_person__person_id integer, description text, url character varying, ai4soilhealth_pilot boolean, general_country__country_id_val character varying, auth_person__contact_person_id_val character varying, auth_person__person_id_val character varying)
LANGUAGE plpgsql
AS $function$
BEGIN
RETURN QUERY (
SELECT t.id, t.name, t.country_id, t.contact_person_id, t.person_id, t.description, t.url, t.ai4soilhealth_pilot, country_id.name, contact_person_id.name, person_id.name
FROM data.pilot t
LEFT JOIN auth.vw_partner v ON v.user_id = t.person_id AND v.partner_user_id = auth.get_context_person_id()
LEFT JOIN general.country country_id ON country_id.id = t.country_id
LEFT JOIN auth.person contact_person_id ON contact_person_id.id = t.contact_person_id
LEFT JOIN auth.person person_id ON person_id.id = t.person_id
WHERE v.user_id IS NOT NULL OR auth.get_context_is_admin()
ORDER BY 2
);
END $function$
*/
}
/**
* @function data_pilot_u
* @memberof zzglc
* @description Data pilot u
* @param {character_varying} Json
* @returns {void}
*/
function data_pilot_u() {
/*
CREATE OR REPLACE FUNCTION zzglc.data_pilot_u("Json" character varying)
RETURNS void
LANGUAGE plpgsql
AS $function$
DECLARE json_data json;
BEGIN
json_data := "Json";
UPDATE data.pilot SET
name = (json_data->>'name')::character varying,
country_id = (json_data->>'country_id')::integer,
contact_person_id = (json_data->>'contact_person_id')::integer,
person_id = (json_data->>'person_id')::integer,
description = (json_data->>'description')::text,
url = (json_data->>'url')::character varying,
ai4soilhealth_pilot = (json_data->>'ai4soilhealth_pilot')::boolean
WHERE id = (json_data->>'id')::integer;
END $function$
*/
}
/**
* @function data_point_c
* @memberof zzglc
* @description Data point c
* @param {character_varying} Json
* @returns {integer}
*/
function data_point_c() {
/*
CREATE OR REPLACE FUNCTION zzglc.data_point_c("Json" character varying)
RETURNS integer
LANGUAGE plpgsql
AS $function$
DECLARE v_id integer;
DECLARE json_data json;
BEGIN
json_data := "Json";
INSERT INTO data.point (point_key, lat, lon, data_source_id, sample, notes, l3_id, elev, name, x, y, site_id, position_error, point_abandoned, person_id, soil_class_id)
VALUES ((json_data->>'point_key')::character varying, (json_data->>'lat')::double precision, (json_data->>'lon')::double precision, (json_data->>'data_source_id')::integer, (json_data->>'sample')::integer, (json_data->>'notes')::character varying, (json_data->>'l3_id')::integer, (json_data->>'elev')::integer, (json_data->>'name')::character varying, (json_data->>'x')::double precision, (json_data->>'y')::double precision, (json_data->>'site_id')::integer, (json_data->>'position_error')::double precision, (json_data->>'point_abandoned')::date, auth.get_context_person_id(), (json_data->>'soil_class_id')::integer)
RETURNING id INTO v_id;
RETURN v_id;
END $function$
*/
}
/**
* @function data_point_d
* @memberof zzglc
* @description Data point d
* @param {integer} Key
* @returns {void}
*/
function data_point_d() {
/*
CREATE OR REPLACE FUNCTION zzglc.data_point_d("Key" integer)
RETURNS void
LANGUAGE plpgsql
AS $function$
BEGIN
DELETE FROM data.point WHERE id = "Key";
END;
$function$
*/
}
/**
* @function data_point_d_overload
* @overload data_point_d
* @memberof zzglc
* @description Data point d
* @param {integer[]} Keys
* @returns {void}
*/
function data_point_d_overload() {
/*
CREATE OR REPLACE FUNCTION zzglc.data_point_d("Keys" integer[])
RETURNS void
LANGUAGE plpgsql
AS $function$
BEGIN
DROP TABLE IF EXISTS ids;
CREATE TEMP TABLE ids AS
SELECT unnest("Keys"::int[]) AS id;
DELETE FROM data.point
USING ids WHERE ids.id = data.point.id;
RETURN;
END $function$
*/
}
/**
* @function data_point_r
* @memberof zzglc
* @description Data point r
* @param {integer} Key
* @returns {Object} integer idcharacter_varying point_keydouble_precision latdouble_precision loninteger data_data_source__data_source_idinteger samplecharacter_varying notesinteger general_nuts__l3_idinteger elevcharacter_varying namedouble_precision xdouble_precision yinteger data_site__site_iddouble_precision position_errordate point_abandonedinteger auth_person__person_idinteger catalog_soil_class__soil_class_idcharacter_varying data_data_source__data_source_id_valcharacter_varying general_nuts__l3_id_valcharacter_varying data_site__site_id_valcharacter_varying auth_person__person_id_valcharacter_varying catalog_soil_class__soil_class_id_val
*/
function data_point_r() {
/*
CREATE OR REPLACE FUNCTION zzglc.data_point_r("Key" integer)
RETURNS TABLE(id integer, point_key character varying, lat double precision, lon double precision, data_data_source__data_source_id integer, sample integer, notes character varying, general_nuts__l3_id integer, elev integer, name character varying, x double precision, y double precision, data_site__site_id integer, position_error double precision, point_abandoned date, auth_person__person_id integer, catalog_soil_class__soil_class_id integer, data_data_source__data_source_id_val character varying, general_nuts__l3_id_val character varying, data_site__site_id_val character varying, auth_person__person_id_val character varying, catalog_soil_class__soil_class_id_val character varying)
LANGUAGE plpgsql
AS $function$
BEGIN
RETURN QUERY (
SELECT t.id, t.point_key, t.lat, t.lon, t.data_source_id, t.sample, t.notes, t.l3_id, t.elev, t.name, t.x, t.y, t.site_id, t.position_error, t.point_abandoned, t.person_id, t.soil_class_id, data_source_id.name, l3_id.nuts_id, site_id.name, person_id.email, soil_class_id.name
FROM data.point t
LEFT JOIN auth.vw_partner vwp ON vwp.user_id = t.person_id AND vwp.partner_user_id = auth.get_context_person_id()
LEFT JOIN data.data_source data_source_id ON data_source_id.id = t.data_source_id
LEFT JOIN general.nuts l3_id ON l3_id.id = t.l3_id
LEFT JOIN data.site site_id ON site_id.id = t.site_id
LEFT JOIN auth.person person_id ON person_id.id = t.person_id
LEFT JOIN catalog.soil_class soil_class_id ON soil_class_id.id = t.soil_class_id
WHERE t.site_id = "Key"
ORDER BY 2
);
END $function$
*/
}
/**
* @function data_point_r_overload
* @overload data_point_r
* @memberof zzglc
* @description Data point r
* @returns {Object} integer idcharacter_varying point_keydouble_precision latdouble_precision loninteger data_data_source__data_source_idinteger samplecharacter_varying notesinteger general_nuts__l3_idinteger elevcharacter_varying namedouble_precision xdouble_precision yinteger data_site__site_iddouble_precision position_errordate point_abandonedinteger auth_person__person_idinteger catalog_soil_class__soil_class_idcharacter_varying data_data_source__data_source_id_valcharacter_varying general_nuts__l3_id_valcharacter_varying data_site__site_id_valcharacter_varying auth_person__person_id_valcharacter_varying catalog_soil_class__soil_class_id_val
*/
function data_point_r_overload() {
/*
CREATE OR REPLACE FUNCTION zzglc.data_point_r()
RETURNS TABLE(id integer, point_key character varying, lat double precision, lon double precision, data_data_source__data_source_id integer, sample integer, notes character varying, general_nuts__l3_id integer, elev integer, name character varying, x double precision, y double precision, data_site__site_id integer, position_error double precision, point_abandoned date, auth_person__person_id integer, catalog_soil_class__soil_class_id integer, data_data_source__data_source_id_val character varying, general_nuts__l3_id_val character varying, data_site__site_id_val character varying, auth_person__person_id_val character varying, catalog_soil_class__soil_class_id_val character varying)
LANGUAGE plpgsql
AS $function$
BEGIN
RETURN QUERY (
SELECT t.id, t.point_key, t.lat, t.lon, t.data_source_id, t.sample, t.notes, t.l3_id, t.elev, t.name, t.x, t.y, t.site_id, t.position_error, t.point_abandoned, t.person_id, t.soil_class_id, data_source_id.name, l3_id.nuts_id, site_id.name, person_id.email, soil_class_id.name
FROM data.point t
LEFT JOIN auth.vw_partner vwp ON vwp.user_id = t.person_id AND vwp.partner_user_id = auth.get_context_person_id()
LEFT JOIN data.data_source data_source_id ON data_source_id.id = t.data_source_id
LEFT JOIN general.nuts l3_id ON l3_id.id = t.l3_id
LEFT JOIN data.site site_id ON site_id.id = t.site_id
LEFT JOIN auth.person person_id ON person_id.id = t.person_id
LEFT JOIN catalog.soil_class soil_class_id ON soil_class_id.id = t.soil_class_id
WHERE vwp.user_id = auth.get_context_person_id() OR auth.get_context_is_admin()
ORDER BY 2
);
END $function$
*/
}
/**
* @function data_point_s_r
* @memberof zzglc
* @description Data point s r
* @param {integer} Key
* @returns {Object} integer idcharacter_varying point_keydouble_precision latdouble_precision loninteger data_data_source__data_source_idinteger samplecharacter_varying notesinteger general_nuts__l3_idinteger elevcharacter_varying namedouble_precision xdouble_precision yinteger data_site__site_iddouble_precision position_errordate point_abandonedinteger auth_person__person_idcharacter_varying data_data_source__data_source_id_valcharacter_varying general_nuts__l3_id_valcharacter_varying data_site__site_id_valcharacter_varying auth_person__person_id_val
*/
function data_point_s_r() {
/*
CREATE OR REPLACE FUNCTION zzglc.data_point_s_r("Key" integer)
RETURNS TABLE(id integer, point_key character varying, lat double precision, lon double precision, data_data_source__data_source_id integer, sample integer, notes character varying, general_nuts__l3_id integer, elev integer, name character varying, x double precision, y double precision, data_site__site_id integer, position_error double precision, point_abandoned date, auth_person__person_id integer, data_data_source__data_source_id_val character varying, general_nuts__l3_id_val character varying, data_site__site_id_val character varying, auth_person__person_id_val character varying)
LANGUAGE plpgsql
AS $function$
BEGIN
RETURN QUERY (
SELECT t.id, t.point_key, t.lat, t.lon, t.data_source_id, t.sample, t.notes, t.l3_id, t.elev, t.name, t.x, t.y, t.site_id, t.position_error, t.point_abandoned, t.person_id, data_source_id.name, l3_id.nuts_id, site_id.name, person_id.name
FROM data.point t
LEFT JOIN data.data_source data_source_id ON data_source_id.id = t.data_source_id
LEFT JOIN general.nuts l3_id ON l3_id.id = t.l3_id
LEFT JOIN data.site site_id ON site_id.id = t.site_id
LEFT JOIN auth.person person_id ON person_id.id = t.person_id
WHERE t.id = "Key"
ORDER BY 2
);
END $function$
*/
}
/**
* @function data_point_state_c
* @memberof zzglc
* @description Data point state c
* @param {character_varying} Json
* @returns {integer}
*/
function data_point_state_c() {
/*
CREATE OR REPLACE FUNCTION zzglc.data_point_state_c("Json" character varying)
RETURNS integer
LANGUAGE plpgsql
AS $function$
DECLARE v_id integer;
DECLARE json_data json;
BEGIN
json_data := "Json";
INSERT INTO data.point_state (sampling_log_id, tree_presence, shrub_presence, graminoid_presence, forb_presence, lichen_moss_presence, crop_growth_stage_id, visible_sheet_erosion, visible_rill_erosion, visible_gully_erosion, visible_wind_erosion, erosion_measure_id, rock_cover_percent, stone_cover_percent, gravel_cover_percent, bare_rock_presence)
VALUES ((json_data->>'sampling_log_id')::integer, (json_data->>'tree_presence')::boolean, (json_data->>'shrub_presence')::boolean, (json_data->>'graminoid_presence')::boolean, (json_data->>'forb_presence')::boolean, (json_data->>'lichen_moss_presence')::boolean, (json_data->>'crop_growth_stage_id')::integer, (json_data->>'visible_sheet_erosion')::boolean, (json_data->>'visible_rill_erosion')::boolean, (json_data->>'visible_gully_erosion')::boolean, (json_data->>'visible_wind_erosion')::boolean, (json_data->>'erosion_measure_id')::integer, (json_data->>'rock_cover_percent')::smallint, (json_data->>'stone_cover_percent')::smallint, (json_data->>'gravel_cover_percent')::smallint, (json_data->>'bare_rock_presence')::boolean)
RETURNING id INTO v_id;
RETURN v_id;
END $function$
*/
}
/**
* @function data_point_state_d
* @memberof zzglc
* @description Data point state d
* @param {integer} Key
* @returns {void}
*/
function data_point_state_d() {
/*
CREATE OR REPLACE FUNCTION zzglc.data_point_state_d("Key" integer)
RETURNS void
LANGUAGE plpgsql
AS $function$
BEGIN
DELETE FROM data.point_state WHERE id = "Key";
END;
$function$
*/
}
/**
* @function data_point_state_r
* @memberof zzglc
* @description Data point state r
* @param {integer} Key
* @returns {Object} integer idinteger data_sampling_log__sampling_log_idboolean tree_presenceboolean shrub_presenceboolean graminoid_presenceboolean forb_presenceboolean lichen_moss_presenceinteger catalog_crop_growth_stage__crop_growth_stage_idboolean visible_sheet_erosionboolean visible_rill_erosionboolean visible_gully_erosionboolean visible_wind_erosioninteger catalog_erosion_conservation_measure__erosion_measure_idsmallint rock_cover_percentsmallint stone_cover_percentsmallint gravel_cover_percentboolean bare_rock_presencecharacter_varying data_sampling_log__sampling_log_id_valcharacter_varying catalog_crop_growth_stage__crop_growth_stage_id_valcharacter_varying catalog_erosion_conservation_measure__erosion_measure_id_val
*/
function data_point_state_r() {
/*
CREATE OR REPLACE FUNCTION zzglc.data_point_state_r("Key" integer)
RETURNS TABLE(id integer, data_sampling_log__sampling_log_id integer, tree_presence boolean, shrub_presence boolean, graminoid_presence boolean, forb_presence boolean, lichen_moss_presence boolean, catalog_crop_growth_stage__crop_growth_stage_id integer, visible_sheet_erosion boolean, visible_rill_erosion boolean, visible_gully_erosion boolean, visible_wind_erosion boolean, catalog_erosion_conservation_measure__erosion_measure_id integer, rock_cover_percent smallint, stone_cover_percent smallint, gravel_cover_percent smallint, bare_rock_presence boolean, data_sampling_log__sampling_log_id_val character varying, catalog_crop_growth_stage__crop_growth_stage_id_val character varying, catalog_erosion_conservation_measure__erosion_measure_id_val character varying)
LANGUAGE plpgsql
AS $function$
BEGIN
RETURN QUERY (
SELECT t.id, t.sampling_log_id, t.tree_presence, t.shrub_presence, t.graminoid_presence, t.forb_presence, t.lichen_moss_presence, t.crop_growth_stage_id, t.visible_sheet_erosion, t.visible_rill_erosion, t.visible_gully_erosion, t.visible_wind_erosion, t.erosion_measure_id, t.rock_cover_percent, t.stone_cover_percent, t.gravel_cover_percent, t.bare_rock_presence, sampling_log_id.name, crop_growth_stage_id.name, erosion_measure_id.name
FROM data.point_state t
LEFT JOIN data.sampling_log sampling_log_id ON sampling_log_id.id = t.sampling_log_id
LEFT JOIN catalog.crop_growth_stage crop_growth_stage_id ON crop_growth_stage_id.id = t.crop_growth_stage_id
LEFT JOIN catalog.erosion_conservation_measure erosion_measure_id ON erosion_measure_id.id = t.erosion_measure_id
WHERE t.sampling_log_id = "Key"
ORDER BY 2
);
END $function$
*/
}
/**
* @function data_point_state_r_overload
* @overload data_point_state_r
* @memberof zzglc
* @description Data point state r
* @returns {Object} integer idinteger data_sampling_log__sampling_log_idboolean tree_presenceboolean shrub_presenceboolean graminoid_presenceboolean forb_presenceboolean lichen_moss_presenceinteger catalog_crop_growth_stage__crop_growth_stage_idboolean visible_sheet_erosionboolean visible_rill_erosionboolean visible_gully_erosionboolean visible_wind_erosioninteger catalog_erosion_conservation_measure__erosion_measure_idsmallint rock_cover_percentsmallint stone_cover_percentsmallint gravel_cover_percentboolean bare_rock_presencecharacter_varying data_sampling_log__sampling_log_id_valcharacter_varying catalog_crop_growth_stage__crop_growth_stage_id_valcharacter_varying catalog_erosion_conservation_measure__erosion_measure_id_val
*/
function data_point_state_r_overload() {
/*
CREATE OR REPLACE FUNCTION zzglc.data_point_state_r()
RETURNS TABLE(id integer, data_sampling_log__sampling_log_id integer, tree_presence boolean, shrub_presence boolean, graminoid_presence boolean, forb_presence boolean, lichen_moss_presence boolean, catalog_crop_growth_stage__crop_growth_stage_id integer, visible_sheet_erosion boolean, visible_rill_erosion boolean, visible_gully_erosion boolean, visible_wind_erosion boolean, catalog_erosion_conservation_measure__erosion_measure_id integer, rock_cover_percent smallint, stone_cover_percent smallint, gravel_cover_percent smallint, bare_rock_presence boolean, data_sampling_log__sampling_log_id_val character varying, catalog_crop_growth_stage__crop_growth_stage_id_val character varying, catalog_erosion_conservation_measure__erosion_measure_id_val character varying)
LANGUAGE plpgsql
AS $function$
BEGIN
RETURN QUERY (
SELECT t.id, t.sampling_log_id, t.tree_presence, t.shrub_presence, t.graminoid_presence, t.forb_presence, t.lichen_moss_presence, t.crop_growth_stage_id, t.visible_sheet_erosion, t.visible_rill_erosion, t.visible_gully_erosion, t.visible_wind_erosion, t.erosion_measure_id, t.rock_cover_percent, t.stone_cover_percent, t.gravel_cover_percent, t.bare_rock_presence, sampling_log_id.name, crop_growth_stage_id.name, erosion_measure_id.name
FROM data.point_state t
LEFT JOIN data.sampling_log sampling_log_id ON sampling_log_id.id = t.sampling_log_id
LEFT JOIN catalog.crop_growth_stage crop_growth_stage_id ON crop_growth_stage_id.id = t.crop_growth_stage_id
LEFT JOIN catalog.erosion_conservation_measure erosion_measure_id ON erosion_measure_id.id = t.erosion_measure_id
ORDER BY 2
);
END $function$
*/
}
/**
* @function data_point_state_u
* @memberof zzglc
* @description Data point state u
* @param {character_varying} Json
* @returns {integer}
*/
function data_point_state_u() {
/*
CREATE OR REPLACE FUNCTION zzglc.data_point_state_u("Json" character varying)
RETURNS integer
LANGUAGE plpgsql
AS $function$
DECLARE v_id integer;
DECLARE json_data json;
BEGIN
json_data := "Json";
v_id := (json_data->>'id')::integer;
UPDATE data.point_state SET
sampling_log_id = (json_data->>'sampling_log_id')::integer,
tree_presence = (json_data->>'tree_presence')::boolean,
shrub_presence = (json_data->>'shrub_presence')::boolean,
graminoid_presence = (json_data->>'graminoid_presence')::boolean,
forb_presence = (json_data->>'forb_presence')::boolean,
lichen_moss_presence = (json_data->>'lichen_moss_presence')::boolean,
crop_growth_stage_id = (json_data->>'crop_growth_stage_id')::integer,
visible_sheet_erosion = (json_data->>'visible_sheet_erosion')::boolean,
visible_rill_erosion = (json_data->>'visible_rill_erosion')::boolean,
visible_gully_erosion = (json_data->>'visible_gully_erosion')::boolean,
visible_wind_erosion = (json_data->>'visible_wind_erosion')::boolean,
erosion_measure_id = (json_data->>'erosion_measure_id')::integer,
rock_cover_percent = (json_data->>'rock_cover_percent')::smallint,
stone_cover_percent = (json_data->>'stone_cover_percent')::smallint,
gravel_cover_percent = (json_data->>'gravel_cover_percent')::smallint,
bare_rock_presence = (json_data->>'bare_rock_presence')::boolean
WHERE id = v_id;
RETURN v_id;
END $function$
*/
}
/**
* @function data_point_u
* @memberof zzglc
* @description Data point u
* @param {character_varying} Json
* @returns {integer}
*/
function data_point_u() {
/*
CREATE OR REPLACE FUNCTION zzglc.data_point_u("Json" character varying)
RETURNS integer
LANGUAGE plpgsql
AS $function$
DECLARE v_id integer;
DECLARE json_data json;
BEGIN
json_data := "Json";
v_id := (json_data->>'id')::integer;
UPDATE data.point SET
point_key = (json_data->>'point_key')::character varying,
lat = (json_data->>'lat')::double precision,
lon = (json_data->>'lon')::double precision,
data_source_id = (json_data->>'data_source_id')::integer,
sample = (json_data->>'sample')::integer,
notes = (json_data->>'notes')::character varying,
l3_id = (json_data->>'l3_id')::integer,
elev = (json_data->>'elev')::integer,
name = (json_data->>'name')::character varying,
x = (json_data->>'x')::double precision,
y = (json_data->>'y')::double precision,
site_id = (json_data->>'site_id')::integer,
position_error = (json_data->>'position_error')::double precision,
point_abandoned = (json_data->>'point_abandoned')::date,
person_id = (json_data->>'person_id')::integer,
soil_class_id = (json_data->>'soil_class_id')::integer
WHERE id = v_id;
RETURN v_id;
END $function$
*/
}
/**
* @function data_prediction_model_c
* @memberof zzglc
* @description Data prediction model c
* @param {character_varying} Json
* @returns {integer}
*/
function data_prediction_model_c() {
/*
CREATE OR REPLACE FUNCTION zzglc.data_prediction_model_c("Json" character varying)
RETURNS integer
LANGUAGE plpgsql
AS $function$
DECLARE v_id integer;
DECLARE json_data json;
BEGIN
json_data := "Json";
INSERT INTO data.prediction_model (method, indicator, model)
VALUES ((json_data->>'method')::character varying, (json_data->>'indicator')::character varying, (json_data->>'model')::bytea)
RETURNING id INTO v_id;
RETURN v_id;
END $function$
*/
}
/**
* @function data_prediction_model_d
* @memberof zzglc
* @description Data prediction model d
* @param {integer} Key
* @returns {void}
*/
function data_prediction_model_d() {
/*
CREATE OR REPLACE FUNCTION zzglc.data_prediction_model_d("Key" integer)
RETURNS void
LANGUAGE plpgsql
AS $function$
BEGIN
DELETE FROM data.prediction_model WHERE id = "Key";
END;
$function$
*/
}
/**
* @function data_prediction_model_r
* @memberof zzglc
* @description Data prediction model r
* @returns {Object} integer idcharacter_varying methodcharacter_varying indicatorbytea model
*/
function data_prediction_model_r() {
/*
CREATE OR REPLACE FUNCTION zzglc.data_prediction_model_r()
RETURNS TABLE(id integer, method character varying, indicator character varying, model bytea)
LANGUAGE plpgsql
AS $function$
BEGIN
RETURN QUERY (
SELECT t.id, t.method, t.indicator, t.model
FROM data.prediction_model t
);
END $function$
*/
}
/**
* @function data_prediction_model_u
* @memberof zzglc
* @description Data prediction model u
* @param {character_varying} Json
* @returns {void}
*/
function data_prediction_model_u() {
/*
CREATE OR REPLACE FUNCTION zzglc.data_prediction_model_u("Json" character varying)
RETURNS void
LANGUAGE plpgsql
AS $function$
DECLARE json_data json;
BEGIN
json_data := "Json";
UPDATE data.prediction_model SET
method = (json_data->>'method')::character varying,
indicator = (json_data->>'indicator')::character varying,
model = (json_data->>'model')::bytea
WHERE id = (json_data->>'id')::integer;
END $function$
*/
}
/**
* @function data_property_c
* @memberof zzglc
* @description Data property c
* @param {character_varying} Json
* @returns {integer}
*/
function data_property_c() {
/*
CREATE OR REPLACE FUNCTION zzglc.data_property_c("Json" character varying)
RETURNS integer
LANGUAGE plpgsql
AS $function$
DECLARE v_id integer;
BEGIN
INSERT INTO data.property (
name,
indicator_id,
unit_id,
data_type_id,
numerical,
mask
)
SELECT
U.name,
U.indicator_id,
U.unit_id,
U.data_type_id,
U.numerical,
U.mask
FROM
json_to_record("Json"::json) U (
name character varying(255),
indicator_id integer,
unit_id integer,
data_type_id integer,
numerical boolean,
mask character varying(255)
)
RETURNING id INTO v_id;
RETURN v_id;
END $function$
*/
}
/**
* @function data_property_d
* @memberof zzglc
* @description Data property d
* @param {integer} Key
* @returns {void}
*/
function data_property_d() {
/*
CREATE OR REPLACE FUNCTION zzglc.data_property_d("Key" integer)
RETURNS void
LANGUAGE plpgsql
AS $function$
BEGIN
DELETE FROM data.property
WHERE id = "Key";
END $function$
*/
}
/**
* @function data_property_r
* @memberof zzglc
* @description Data property r
* @returns {Object}
* @property {integer} id
* @property {character_varying} name
* @property {integer} indicator_id
* @property {integer} unit_id
* @property {integer} data_type_id
* @property {boolean} numerical
* @property {character_varying} mask
* @property {character_varying} indicator_id_val
* @property {character_varying} unit_id_val
* @property {character_varying} _data_type_id_val
*/
function data_property_r() {
/*
CREATE OR REPLACE FUNCTION zzglc.data_property_r()
RETURNS TABLE(id integer, name character varying, indicator_id integer, catalog_unit__unit_id integer, meta_data_type__data_type_id integer, numerical boolean, mask character varying, indicator_id_val character varying, catalog_unit__unit_id_val character varying, meta_data_type__data_type_id_val character varying)
LANGUAGE plpgsql
AS $function$
BEGIN
RETURN QUERY
SELECT
t.id, t.name, t.indicator_id, t.unit_id, t.data_type_id, t.numerical, t.mask
, indicator_id_t.name::VARCHAR AS indicator_id_val
, unit_id_t.name::VARCHAR AS unit_id_val
, dt.name::VARCHAR AS data_type_id_val
FROM data.property t
LEFT JOIN data.indicator indicator_id_t ON indicator_id_t.id = t.indicator_id
LEFT JOIN catalog.unit unit_id_t ON unit_id_t.id = t.unit_id
LEFT JOIN meta.data_type dt ON dt.id = t.data_type_id
ORDER BY t.name
;
END $function$
*/
}
/**
* @function data_property_u
* @memberof zzglc
* @description Data property u
* @param {character_varying} Json
* @returns {void}
*/
function data_property_u() {
/*
CREATE OR REPLACE FUNCTION zzglc.data_property_u("Json" character varying)
RETURNS void
LANGUAGE plpgsql
AS $function$
DECLARE v_row_count INTEGER;
BEGIN
UPDATE data.property t
SET name = U.name,
indicator_id = U.indicator_id,
unit_id = U.unit_id,
data_type_id = U.data_type_id,
numerical = U.numerical,
mask = U.mask
FROM json_to_record("Json"::json) AS U (
id integer,
name character varying(255),
indicator_id integer,
unit_id integer,
data_type_id integer,
numerical boolean,
mask character varying(255)
)
WHERE U.id = t.id
;
END $function$
*/
}
/**
* @function data_sample_c
* @memberof zzglc
* @description Data sample c
* @param {character_varying} Json
* @returns {integer}
*/
function data_sample_c() {
/*
CREATE OR REPLACE FUNCTION zzglc.data_sample_c("Json" character varying)
RETURNS integer
LANGUAGE plpgsql
AS $function$
DECLARE v_id integer;
DECLARE json_data json;
BEGIN
json_data := "Json";
INSERT INTO data.sample (sampling_log_id, date_stamp, name, person_id, comment, sample_type_id, min_depth, max_depth)
VALUES ((json_data->>'sampling_log_id')::integer, (json_data->>'date_stamp')::timestamp with time zone, (json_data->>'name')::character varying, auth.get_context_person_id(), (json_data->>'comment')::text, (json_data->>'sample_type_id')::integer, (json_data->>'min_depth')::integer, (json_data->>'max_depth')::integer)
RETURNING id INTO v_id;
RETURN v_id;
END $function$
*/
}
/**
* @function data_sample_d
* @memberof zzglc
* @description Data sample d
* @param {integer} Key
* @returns {void}
*/
function data_sample_d() {
/*
CREATE OR REPLACE FUNCTION zzglc.data_sample_d("Key" integer)
RETURNS void
LANGUAGE plpgsql
AS $function$
BEGIN
DELETE FROM data.sample WHERE id = "Key";
END;
$function$
*/
}
/**
* @function data_sample_mass_c
* @memberof zzglc
* @description Data sample mass c
* @param {character_varying} Json
* @returns {integer}
*/
function data_sample_mass_c() {
/*
CREATE OR REPLACE FUNCTION zzglc.data_sample_mass_c("Json" character varying)
RETURNS integer
LANGUAGE plpgsql
AS $function$
DECLARE v_id integer;
DECLARE json_data json;
BEGIN
json_data := "Json";
INSERT INTO data.sample_mass (sample_id, topsoil, repeat, soil_moisture_method_id, density)
VALUES ((json_data->>'sample_id')::integer, (json_data->>'topsoil')::boolean, (json_data->>'repeat')::smallint, (json_data->>'soil_moisture_method_id')::integer, (json_data->>'density')::double precision)
RETURNING id INTO v_id;
RETURN v_id;
END $function$
*/
}
/**
* @function data_sample_mass_d
* @memberof zzglc
* @description Data sample mass d
* @param {integer} Key
* @returns {void}
*/
function data_sample_mass_d() {
/*
CREATE OR REPLACE FUNCTION zzglc.data_sample_mass_d("Key" integer)
RETURNS void
LANGUAGE plpgsql
AS $function$
BEGIN
DELETE FROM data.sample_mass WHERE id = "Key";
END;
$function$
*/
}
/**
* @function data_sample_mass_r
* @memberof zzglc
* @description Data sample mass r
* @param {integer} Key
* @returns {Object} integer idinteger data_sample__sample_idboolean topsoilsmallint repeatinteger catalog_soil_moisture_method__soil_moisture_method_iddouble_precision densitycharacter_varying data_sample__sample_id_valcharacter_varying catalog_soil_moisture_method__soil_moisture_method_id_val
*/
function data_sample_mass_r() {
/*
CREATE OR REPLACE FUNCTION zzglc.data_sample_mass_r("Key" integer)
RETURNS TABLE(id integer, data_sample__sample_id integer, topsoil boolean, repeat smallint, catalog_soil_moisture_method__soil_moisture_method_id integer, density double precision, data_sample__sample_id_val character varying, catalog_soil_moisture_method__soil_moisture_method_id_val character varying)
LANGUAGE plpgsql
AS $function$
BEGIN
RETURN QUERY (
SELECT t.id, t.sample_id, t.topsoil, t.repeat, t.soil_moisture_method_id, t.density, sample_id.name, soil_moisture_method_id.name
FROM data.sample_mass t
LEFT JOIN data.sample sample_id ON sample_id.id = t.sample_id
LEFT JOIN catalog.soil_moisture_method soil_moisture_method_id ON soil_moisture_method_id.id = t.soil_moisture_method_id
WHERE t.sample_id = "Key"
ORDER BY 2
);
END $function$
*/
}
/**
* @function data_sample_mass_r_overload
* @overload data_sample_mass_r
* @memberof zzglc
* @description Data sample mass r
* @returns {Object} integer idinteger data_sample__sample_idboolean topsoilsmallint repeatinteger catalog_soil_moisture_method__soil_moisture_method_iddouble_precision densitycharacter_varying data_sample__sample_id_valcharacter_varying catalog_soil_moisture_method__soil_moisture_method_id_val
*/
function data_sample_mass_r_overload() {
/*
CREATE OR REPLACE FUNCTION zzglc.data_sample_mass_r()
RETURNS TABLE(id integer, data_sample__sample_id integer, topsoil boolean, repeat smallint, catalog_soil_moisture_method__soil_moisture_method_id integer, density double precision, data_sample__sample_id_val character varying, catalog_soil_moisture_method__soil_moisture_method_id_val character varying)
LANGUAGE plpgsql
AS $function$
BEGIN
RETURN QUERY (
SELECT t.id, t.sample_id, t.topsoil, t.repeat, t.soil_moisture_method_id, t.density, sample_id.name, soil_moisture_method_id.name
FROM data.sample_mass t
LEFT JOIN data.sample sample_id ON sample_id.id = t.sample_id
LEFT JOIN catalog.soil_moisture_method soil_moisture_method_id ON soil_moisture_method_id.id = t.soil_moisture_method_id
ORDER BY 2
);
END $function$
*/
}
/**
* @function data_sample_mass_u
* @memberof zzglc
* @description Data sample mass u
* @param {character_varying} Json
* @returns {integer}
*/
function data_sample_mass_u() {
/*
CREATE OR REPLACE FUNCTION zzglc.data_sample_mass_u("Json" character varying)
RETURNS integer
LANGUAGE plpgsql
AS $function$
DECLARE v_id integer;
DECLARE json_data json;
BEGIN
json_data := "Json";
v_id := (json_data->>'id')::integer;
UPDATE data.sample_mass SET
sample_id = (json_data->>'sample_id')::integer,
topsoil = (json_data->>'topsoil')::boolean,
repeat = (json_data->>'repeat')::smallint,
soil_moisture_method_id = (json_data->>'soil_moisture_method_id')::integer,
density = (json_data->>'density')::double precision
WHERE id = v_id;
RETURN v_id;
END $function$
*/
}
/**
* @function data_sample_r
* @memberof zzglc
* @description Data sample r
* @param {integer} Key
* @returns {Object} integer idinteger data_sampling_log__sampling_log_idtimestamp_with_time_zone date_stampcharacter_varying nameinteger auth_person__person_idtext commentinteger catalog_sample_type__sample_type_idinteger min_depthinteger max_depthcharacter_varying data_sampling_log__sampling_log_id_valcharacter_varying auth_person__person_id_valcharacter_varying catalog_sample_type__sample_type_id_val
*/
function data_sample_r() {
/*
CREATE OR REPLACE FUNCTION zzglc.data_sample_r("Key" integer)
RETURNS TABLE(id integer, data_sampling_log__sampling_log_id integer, date_stamp timestamp with time zone, name character varying, auth_person__person_id integer, comment text, catalog_sample_type__sample_type_id integer, min_depth integer, max_depth integer, data_sampling_log__sampling_log_id_val character varying, auth_person__person_id_val character varying, catalog_sample_type__sample_type_id_val character varying)
LANGUAGE plpgsql
AS $function$
BEGIN
RETURN QUERY (
SELECT t.id, t.sampling_log_id, t.date_stamp, t.name, t.person_id, t.comment, t.sample_type_id, t.min_depth, t.max_depth, sampling_log_id.name, person_id.email, sample_type_id.name
FROM data.sample t
LEFT JOIN data.sampling_log sampling_log_id ON sampling_log_id.id = t.sampling_log_id
LEFT JOIN auth.person person_id ON person_id.id = t.person_id
LEFT JOIN catalog.sample_type sample_type_id ON sample_type_id.id = t.sample_type_id
WHERE t.sampling_log_id = "Key"
ORDER BY 2
);
END $function$
*/
}
/**
* @function data_sample_r_overload
* @overload data_sample_r
* @memberof zzglc
* @description Data sample r
* @returns {Object} integer idinteger data_sampling_log__sampling_log_idtimestamp_with_time_zone date_stampcharacter_varying nameinteger auth_person__person_idtext commentinteger catalog_sample_type__sample_type_idinteger min_depthinteger max_depthcharacter_varying data_sampling_log__sampling_log_id_valcharacter_varying auth_person__person_id_valcharacter_varying catalog_sample_type__sample_type_id_val
*/
function data_sample_r_overload() {
/*
CREATE OR REPLACE FUNCTION zzglc.data_sample_r()
RETURNS TABLE(id integer, data_sampling_log__sampling_log_id integer, date_stamp timestamp with time zone, name character varying, auth_person__person_id integer, comment text, catalog_sample_type__sample_type_id integer, min_depth integer, max_depth integer, data_sampling_log__sampling_log_id_val character varying, auth_person__person_id_val character varying, catalog_sample_type__sample_type_id_val character varying)
LANGUAGE plpgsql
AS $function$
BEGIN
RETURN QUERY (
SELECT t.id, t.sampling_log_id, t.date_stamp, t.name, t.person_id, t.comment, t.sample_type_id, t.min_depth, t.max_depth, sampling_log_id.name, person_id.email, sample_type_id.name
FROM data.sample t
LEFT JOIN auth.vw_partner vwp ON vwp.user_id = t.person_id AND vwp.partner_user_id = auth.get_context_person_id()
LEFT JOIN data.sampling_log sampling_log_id ON sampling_log_id.id = t.sampling_log_id
LEFT JOIN auth.person person_id ON person_id.id = t.person_id
LEFT JOIN catalog.sample_type sample_type_id ON sample_type_id.id = t.sample_type_id
WHERE vwp.user_id = auth.get_context_person_id() OR auth.get_context_is_admin()
ORDER BY 2
);
END $function$
*/
}
/**
* @function data_sample_u
* @memberof zzglc
* @description Data sample u
* @param {character_varying} Json
* @returns {integer}
*/
function data_sample_u() {
/*
CREATE OR REPLACE FUNCTION zzglc.data_sample_u("Json" character varying)
RETURNS integer
LANGUAGE plpgsql
AS $function$
DECLARE v_id integer;
DECLARE json_data json;
BEGIN
json_data := "Json";
v_id := (json_data->>'id')::integer;
UPDATE data.sample SET
sampling_log_id = (json_data->>'sampling_log_id')::integer,
date_stamp = (json_data->>'date_stamp')::timestamp with time zone,
name = (json_data->>'name')::character varying,
person_id = (json_data->>'person_id')::integer,
comment = (json_data->>'comment')::text,
sample_type_id = (json_data->>'sample_type_id')::integer,
min_depth = (json_data->>'min_depth')::integer,
max_depth = (json_data->>'max_depth')::integer
WHERE id = v_id;
RETURN v_id;
END $function$
*/
}
/**
* @function data_sampling_checklist_r
* @memberof zzglc
* @description Data sampling checklist r
* @param {integer} Key
* @returns {Object} integer idinteger data_point__point_idboolean wet_chemistryboolean ednaboolean macrofaunaboolean microbiometerboolean moulderboolean fieldobsboolean soil_spectra_noboolean soil_spectra_mxboolean soil_spectra_dsboolean penetrometer_npkphcthboolean enzymesboolean ise_phboolean infiltrationcharacter_varying data_point__point_id_val
*/
function data_sampling_checklist_r() {
/*
CREATE OR REPLACE FUNCTION zzglc.data_sampling_checklist_r("Key" integer)
RETURNS TABLE(id integer, data_point__point_id integer, wet_chemistry boolean, edna boolean, macrofauna boolean, microbiometer boolean, moulder boolean, fieldobs boolean, soil_spectra_no boolean, soil_spectra_mx boolean, soil_spectra_ds boolean, penetrometer_npkphcth boolean, enzymes boolean, ise_ph boolean, infiltration boolean, data_point__point_id_val character varying)
LANGUAGE plpgsql
AS $function$
BEGIN
RETURN QUERY (
SELECT t.id, t.point_id, t.wet_chemistry, t.edna, t.macrofauna, t.microbiometer, t.moulder, t.fieldobs, t.soil_spectra_no, t.soil_spectra_mx, t.soil_spectra_ds, t.penetrometer_npkphcth, t.enzymes, t.ise_ph, t.infiltration, point_id.point_key
FROM data.sampling_checklist t
LEFT JOIN auth.vw_partner vwp ON vwp.user_id = t.person_id AND vwp.partner_user_id = auth.get_context_person_id()
LEFT JOIN data.point point_id ON point_id.id = t.point_id
WHERE t.point_id = "Key"
ORDER BY 2
);
END $function$
*/
}
/**
* @function data_sampling_log_c
* @memberof zzglc
* @description Data sampling log c
* @param {character_varying} Json
* @returns {integer}
*/
function data_sampling_log_c() {
/*
CREATE OR REPLACE FUNCTION zzglc.data_sampling_log_c("Json" character varying)
RETURNS integer
LANGUAGE plpgsql
AS $function$
DECLARE v_id integer;
DECLARE json_data json;
BEGIN
json_data := "Json";
INSERT INTO data.sampling_log (point_id, date_stamp, person_id, name)
VALUES ((json_data->>'point_id')::integer, (json_data->>'date_stamp')::timestamp with time zone, auth.get_context_person_id(), (json_data->>'name')::character varying)
RETURNING id INTO v_id;
RETURN v_id;
END $function$
*/
}
/**
* @function data_sampling_log_d
* @memberof zzglc
* @description Data sampling log d
* @param {integer} Key
* @returns {void}
*/
function data_sampling_log_d() {
/*
CREATE OR REPLACE FUNCTION zzglc.data_sampling_log_d("Key" integer)
RETURNS void
LANGUAGE plpgsql
AS $function$
BEGIN
DELETE FROM data.sampling_log WHERE id = "Key";
END;
$function$
*/
}
/**
* @function data_sampling_log_image_c
* @memberof zzglc
* @description Data sampling log image c
* @param {character_varying} Json
* @returns {integer}
*/
function data_sampling_log_image_c() {
/*
CREATE OR REPLACE FUNCTION zzglc.data_sampling_log_image_c("Json" character varying)
RETURNS integer
LANGUAGE plpgsql
AS $function$
DECLARE v_id integer;
DECLARE json_data json;
BEGIN
json_data := "Json";
INSERT INTO data.sampling_log_image (direction_id, person_id, sampling_log_id)
VALUES ((json_data->>'direction_id')::integer, auth.get_context_person_id(), (json_data->>'sampling_log_id')::integer)
RETURNING id INTO v_id;
RETURN v_id;
END $function$
*/
}
/**
* @function data_sampling_log_image_d
* @memberof zzglc
* @description Data sampling log image d
* @param {integer} Key
* @returns {void}
*/
function data_sampling_log_image_d() {
/*
CREATE OR REPLACE FUNCTION zzglc.data_sampling_log_image_d("Key" integer)
RETURNS void
LANGUAGE plpgsql
AS $function$
BEGIN
DELETE FROM data.sampling_log_image WHERE id = "Key";
END;
$function$
*/
}
/**
* @function data_sampling_log_image_r
* @memberof zzglc
* @description Data sampling log image r
* @param {integer} Key
* @returns {Object} integer idinteger catalog_direction__direction_idinteger auth_person__person_idinteger data_sampling_log__sampling_log_idcharacter_varying catalog_direction__direction_id_valcharacter_varying auth_person__person_id_valcharacter_varying data_sampling_log__sampling_log_id_val
*/
function data_sampling_log_image_r() {
/*
CREATE OR REPLACE FUNCTION zzglc.data_sampling_log_image_r("Key" integer)
RETURNS TABLE(id integer, catalog_direction__direction_id integer, auth_person__person_id integer, data_sampling_log__sampling_log_id integer, catalog_direction__direction_id_val character varying, auth_person__person_id_val character varying, data_sampling_log__sampling_log_id_val character varying)
LANGUAGE plpgsql
AS $function$
BEGIN
RETURN QUERY (
SELECT t.id, t.direction_id, t.person_id, t.sampling_log_id, direction_id.name, person_id.email, sampling_log_id.name
FROM data.sampling_log_image t
LEFT JOIN auth.vw_partner vwp ON vwp.user_id = t.person_id AND vwp.partner_user_id = auth.get_context_person_id()
LEFT JOIN catalog.direction direction_id ON direction_id.id = t.direction_id
LEFT JOIN auth.person person_id ON person_id.id = t.person_id
LEFT JOIN data.sampling_log sampling_log_id ON sampling_log_id.id = t.sampling_log_id
WHERE t.sampling_log_id = "Key"
ORDER BY 2
);
END $function$
*/
}
/**
* @function data_sampling_log_image_r_overload
* @overload data_sampling_log_image_r
* @memberof zzglc
* @description Data sampling log image r
* @returns {Object} integer idinteger catalog_direction__direction_idinteger auth_person__person_idinteger data_sampling_log__sampling_log_idcharacter_varying catalog_direction__direction_id_valcharacter_varying auth_person__person_id_valcharacter_varying data_sampling_log__sampling_log_id_val
*/
function data_sampling_log_image_r_overload() {
/*
CREATE OR REPLACE FUNCTION zzglc.data_sampling_log_image_r()
RETURNS TABLE(id integer, catalog_direction__direction_id integer, auth_person__person_id integer, data_sampling_log__sampling_log_id integer, catalog_direction__direction_id_val character varying, auth_person__person_id_val character varying, data_sampling_log__sampling_log_id_val character varying)
LANGUAGE plpgsql
AS $function$
BEGIN
RETURN QUERY (
SELECT t.id, t.direction_id, t.person_id, t.sampling_log_id, direction_id.name, person_id.email, sampling_log_id.name
FROM data.sampling_log_image t
LEFT JOIN auth.vw_partner vwp ON vwp.user_id = t.person_id AND vwp.partner_user_id = auth.get_context_person_id()
LEFT JOIN catalog.direction direction_id ON direction_id.id = t.direction_id
LEFT JOIN auth.person person_id ON person_id.id = t.person_id
LEFT JOIN data.sampling_log sampling_log_id ON sampling_log_id.id = t.sampling_log_id
WHERE vwp.user_id = auth.get_context_person_id() OR auth.get_context_is_admin()
ORDER BY 2
);
END $function$
*/
}
/**
* @function data_sampling_log_image_u
* @memberof zzglc
* @description Data sampling log image u
* @param {character_varying} Json
* @returns {integer}
*/
function data_sampling_log_image_u() {
/*
CREATE OR REPLACE FUNCTION zzglc.data_sampling_log_image_u("Json" character varying)
RETURNS integer
LANGUAGE plpgsql
AS $function$
DECLARE v_id integer;
DECLARE json_data json;
BEGIN
json_data := "Json";
v_id := (json_data->>'id')::integer;
UPDATE data.sampling_log_image SET
direction_id = (json_data->>'direction_id')::integer,
person_id = (json_data->>'person_id')::integer,
sampling_log_id = (json_data->>'sampling_log_id')::integer
WHERE id = v_id;
RETURN v_id;
END $function$
*/
}
/**
* @function data_sampling_log_r
* @memberof zzglc
* @description Data sampling log r
* @param {integer} Key
* @returns {Object} integer idinteger data_point__point_idtimestamp_with_time_zone date_stampinteger auth_person__person_idcharacter_varying namecharacter_varying data_point__point_id_valcharacter_varying auth_person__person_id_val
*/
function data_sampling_log_r() {
/*
CREATE OR REPLACE FUNCTION zzglc.data_sampling_log_r("Key" integer)
RETURNS TABLE(id integer, data_point__point_id integer, date_stamp timestamp with time zone, auth_person__person_id integer, name character varying, data_point__point_id_val character varying, auth_person__person_id_val character varying)
LANGUAGE plpgsql
AS $function$
BEGIN
RETURN QUERY (
SELECT t.id, t.point_id, t.date_stamp, t.person_id, t.name, point_id.point_key, person_id.email
FROM data.sampling_log t
LEFT JOIN auth.vw_partner vwp ON vwp.user_id = t.person_id AND vwp.partner_user_id = auth.get_context_person_id()
LEFT JOIN data.point point_id ON point_id.id = t.point_id
LEFT JOIN auth.person person_id ON person_id.id = t.person_id
WHERE t.point_id = "Key"
ORDER BY 2
);
END $function$
*/
}
/**
* @function data_sampling_log_r_overload
* @overload data_sampling_log_r
* @memberof zzglc
* @description Data sampling log r
* @returns {Object} integer idinteger data_point__point_idtimestamp_with_time_zone date_stampinteger auth_person__person_idcharacter_varying namecharacter_varying data_point__point_id_valcharacter_varying auth_person__person_id_val
*/
function data_sampling_log_r_overload() {
/*
CREATE OR REPLACE FUNCTION zzglc.data_sampling_log_r()
RETURNS TABLE(id integer, data_point__point_id integer, date_stamp timestamp with time zone, auth_person__person_id integer, name character varying, data_point__point_id_val character varying, auth_person__person_id_val character varying)
LANGUAGE plpgsql
AS $function$
BEGIN
RETURN QUERY (
SELECT t.id, t.point_id, t.date_stamp, t.person_id, t.name, point_id.point_key, person_id.email
FROM data.sampling_log t
LEFT JOIN auth.vw_partner vwp ON vwp.user_id = t.person_id AND vwp.partner_user_id = auth.get_context_person_id()
LEFT JOIN data.point point_id ON point_id.id = t.point_id
LEFT JOIN auth.person person_id ON person_id.id = t.person_id
WHERE vwp.user_id = auth.get_context_person_id() OR auth.get_context_is_admin()
ORDER BY 2
);
END $function$
*/
}
/**
* @function data_sampling_log_tool_c
* @memberof zzglc
* @description Data sampling log tool c
* @param {character_varying} Json
* @returns {integer}
*/
function data_sampling_log_tool_c() {
/*
CREATE OR REPLACE FUNCTION zzglc.data_sampling_log_tool_c("Json" character varying)
RETURNS integer
LANGUAGE plpgsql
AS $function$
DECLARE v_id integer;
DECLARE json_data json;
BEGIN
json_data := "Json";
INSERT INTO data.sampling_log_tool (direction_id, sampling_log_id, soil_excavation_tool_id, depth_restriction)
VALUES ((json_data->>'direction_id')::integer, (json_data->>'sampling_log_id')::integer, (json_data->>'soil_excavation_tool_id')::integer, (json_data->>'depth_restriction')::integer)
RETURNING id INTO v_id;
RETURN v_id;
END $function$
*/
}
/**
* @function data_sampling_log_tool_d
* @memberof zzglc
* @description Data sampling log tool d
* @param {integer} Key
* @returns {void}
*/
function data_sampling_log_tool_d() {
/*
CREATE OR REPLACE FUNCTION zzglc.data_sampling_log_tool_d("Key" integer)
RETURNS void
LANGUAGE plpgsql
AS $function$
BEGIN
DELETE FROM data.sampling_log_tool WHERE id = "Key";
END;
$function$
*/
}
/**
* @function data_sampling_log_tool_r
* @memberof zzglc
* @description Data sampling log tool r
* @param {integer} Key
* @returns {Object} integer idinteger catalog_direction__direction_idinteger data_sampling_log__sampling_log_idinteger soil_excavation_tool_idinteger depth_restrictioncharacter_varying catalog_direction__direction_id_valcharacter_varying data_sampling_log__sampling_log_id_val
*/
function data_sampling_log_tool_r() {
/*
CREATE OR REPLACE FUNCTION zzglc.data_sampling_log_tool_r("Key" integer)
RETURNS TABLE(id integer, catalog_direction__direction_id integer, data_sampling_log__sampling_log_id integer, soil_excavation_tool_id integer, depth_restriction integer, catalog_direction__direction_id_val character varying, data_sampling_log__sampling_log_id_val character varying)
LANGUAGE plpgsql
AS $function$
BEGIN
RETURN QUERY (
SELECT t.id, t.direction_id, t.sampling_log_id, t.soil_excavation_tool_id, t.depth_restriction, direction_id.name, sampling_log_id.name
FROM data.sampling_log_tool t
LEFT JOIN catalog.direction direction_id ON direction_id.id = t.direction_id
LEFT JOIN data.sampling_log sampling_log_id ON sampling_log_id.id = t.sampling_log_id
WHERE t.sampling_log_id = "Key"
ORDER BY 2
);
END $function$
*/
}
/**
* @function data_sampling_log_tool_r_overload
* @overload data_sampling_log_tool_r
* @memberof zzglc
* @description Data sampling log tool r
* @returns {Object} integer idinteger catalog_direction__direction_idinteger data_sampling_log__sampling_log_idinteger soil_excavation_tool_idinteger depth_restrictioncharacter_varying catalog_direction__direction_id_valcharacter_varying data_sampling_log__sampling_log_id_val
*/
function data_sampling_log_tool_r_overload() {
/*
CREATE OR REPLACE FUNCTION zzglc.data_sampling_log_tool_r()
RETURNS TABLE(id integer, catalog_direction__direction_id integer, data_sampling_log__sampling_log_id integer, soil_excavation_tool_id integer, depth_restriction integer, catalog_direction__direction_id_val character varying, data_sampling_log__sampling_log_id_val character varying)
LANGUAGE plpgsql
AS $function$
BEGIN
RETURN QUERY (
SELECT t.id, t.direction_id, t.sampling_log_id, t.soil_excavation_tool_id, t.depth_restriction, direction_id.name, sampling_log_id.name
FROM data.sampling_log_tool t
LEFT JOIN catalog.direction direction_id ON direction_id.id = t.direction_id
LEFT JOIN data.sampling_log sampling_log_id ON sampling_log_id.id = t.sampling_log_id
ORDER BY 2
);
END $function$
*/
}
/**
* @function data_sampling_log_tool_u
* @memberof zzglc
* @description Data sampling log tool u
* @param {character_varying} Json
* @returns {integer}
*/
function data_sampling_log_tool_u() {
/*
CREATE OR REPLACE FUNCTION zzglc.data_sampling_log_tool_u("Json" character varying)
RETURNS integer
LANGUAGE plpgsql
AS $function$
DECLARE v_id integer;
DECLARE json_data json;
BEGIN
json_data := "Json";
v_id := (json_data->>'id')::integer;
UPDATE data.sampling_log_tool SET
direction_id = (json_data->>'direction_id')::integer,
sampling_log_id = (json_data->>'sampling_log_id')::integer,
soil_excavation_tool_id = (json_data->>'soil_excavation_tool_id')::integer,
depth_restriction = (json_data->>'depth_restriction')::integer
WHERE id = v_id;
RETURN v_id;
END $function$
*/
}
/**
* @function data_sampling_log_u
* @memberof zzglc
* @description Data sampling log u
* @param {character_varying} Json
* @returns {integer}
*/
function data_sampling_log_u() {
/*
CREATE OR REPLACE FUNCTION zzglc.data_sampling_log_u("Json" character varying)
RETURNS integer
LANGUAGE plpgsql
AS $function$
DECLARE v_id integer;
DECLARE json_data json;
BEGIN
json_data := "Json";
v_id := (json_data->>'id')::integer;
UPDATE data.sampling_log SET
point_id = (json_data->>'point_id')::integer,
date_stamp = (json_data->>'date_stamp')::timestamp with time zone,
person_id = (json_data->>'person_id')::integer,
name = (json_data->>'name')::character varying
WHERE id = v_id;
RETURN v_id;
END $function$
*/
}
/**
* @function data_shape_c
* @memberof zzglc
* @description Data shape c
* @param {character_varying} Json
* @returns {void}
*/
function data_shape_c() {
/*
CREATE OR REPLACE FUNCTION zzglc.data_shape_c("Json" character varying)
RETURNS void
LANGUAGE plpgsql
AS $function$
BEGIN
INSERT INTO data.shape (
data_source_id,
name
)
SELECT
U.data_source_id,
U.name
FROM
json_to_record("Json"::json) U (
data_source_id integer,
name character varying(255)
)
;
END $function$
*/
}
/**
* @function data_shape_d
* @memberof zzglc
* @description Data shape d
* @param {integer} Key
* @returns {void}
*/
function data_shape_d() {
/*
CREATE OR REPLACE FUNCTION zzglc.data_shape_d("Key" integer)
RETURNS void
LANGUAGE plpgsql
AS $function$
BEGIN
DELETE FROM data.shape
WHERE id = "Key";
END $function$
*/
}
/**
* @function data_shape_geometry_c
* @memberof zzglc
* @description Data shape geometry c
* @param {character_varying} Json
* @returns {void}
*/
function data_shape_geometry_c() {
/*
CREATE OR REPLACE FUNCTION zzglc.data_shape_geometry_c("Json" character varying)
RETURNS void
LANGUAGE plpgsql
AS $function$
BEGIN
INSERT INTO data.shape_geometry (
shape_id,
properties,
geom
)
SELECT
U.shape_id,
U.properties,
U.geom
FROM
json_to_record("Json"::json) U (
shape_id integer,
properties json,
geom geometry
)
;
END $function$
*/
}
/**
* @function data_shape_geometry_d
* @memberof zzglc
* @description Data shape geometry d
* @param {integer} Key
* @returns {void}
*/
function data_shape_geometry_d() {
/*
CREATE OR REPLACE FUNCTION zzglc.data_shape_geometry_d("Key" integer)
RETURNS void
LANGUAGE plpgsql
AS $function$
BEGIN
DELETE FROM data.shape_geometry
WHERE id = "Key";
END $function$
*/
}
/**
* @function data_shape_geometry_r
* @memberof zzglc
* @description Data shape geometry r
* @param {integer} ShapeId
* @returns {Object}
* @property {integer} id
* @property {integer} shape_id
* @property {json} properties
* @property {character_varying} shape_id_val
*/
function data_shape_geometry_r() {
/*
CREATE OR REPLACE FUNCTION zzglc.data_shape_geometry_r("ShapeId" integer)
RETURNS TABLE(id integer, shape_id integer, properties json, shape_id_val character varying)
LANGUAGE plpgsql
AS $function$
BEGIN
RETURN QUERY
SELECT
t.id, t.shape_id, t.properties
, shape_id_t.name::VARCHAR AS shape_id_val
FROM data.shape_geometry t
LEFT JOIN data.shape shape_id_t ON shape_id_t.id = t.shape_id
WHERE t.shape_id = "ShapeId"
ORDER BY t.shape_id
;
END $function$
*/
}
/**
* @function data_shape_geometry_u
* @memberof zzglc
* @description Data shape geometry u
* @param {character_varying} Json
* @returns {void}
*/
function data_shape_geometry_u() {
/*
CREATE OR REPLACE FUNCTION zzglc.data_shape_geometry_u("Json" character varying)
RETURNS void
LANGUAGE plpgsql
AS $function$
DECLARE v_row_count INTEGER;
BEGIN
UPDATE data.shape_geometry t
SET shape_id = U.shape_id,
properties = U.properties,
geom = U.geom
FROM json_to_record("Json"::json) AS U (
id integer,
shape_id integer,
properties json,
geom geometry
)
WHERE U.id = t.id
;
END $function$
*/
}
/**
* @function data_shape_r
* @memberof zzglc
* @description Data shape r
* @returns {Object}
* @property {integer} id
* @property {integer} data_source_id
* @property {character_varying} name
* @property {character_varying} data_source_id_val
*/
function data_shape_r() {
/*
CREATE OR REPLACE FUNCTION zzglc.data_shape_r()
RETURNS TABLE(id integer, data_data_source__data_source_id integer, name character varying, data_data_source__data_source_id_val character varying)
LANGUAGE plpgsql
AS $function$
BEGIN
RETURN QUERY
SELECT
t.id, t.data_source_id, t.name
, data_source_id_t.name::VARCHAR AS data_source_id_val
FROM data.shape t
LEFT JOIN data.data_source data_source_id_t ON data_source_id_t.id = t.data_source_id
ORDER BY data_source_id_t.name, t.name
;
END $function$
*/
}
/**
* @function data_shape_u
* @memberof zzglc
* @description Data shape u
* @param {character_varying} Json
* @returns {void}
*/
function data_shape_u() {
/*
CREATE OR REPLACE FUNCTION zzglc.data_shape_u("Json" character varying)
RETURNS void
LANGUAGE plpgsql
AS $function$
DECLARE v_row_count INTEGER;
BEGIN
UPDATE data.shape t
SET data_source_id = U.data_source_id,
name = U.name
FROM json_to_record("Json"::json) AS U (
id integer,
data_source_id integer,
name character varying(255)
)
WHERE U.id = t.id
;
END $function$
*/
}
/**
* @function data_shdc_c
* @memberof zzglc
* @description Data shdc c
* @param {character_varying} Json
* @returns {integer}
*/
function data_shdc_c() {
/*
CREATE OR REPLACE FUNCTION zzglc.data_shdc_c("Json" character varying)
RETURNS integer
LANGUAGE plpgsql
AS $function$
DECLARE v_id integer;
DECLARE json_data json;
BEGIN
json_data := "Json";
INSERT INTO data.shdc (property, indicator_id, scale_factor, no_data, details, qml, sld, file_name, color_map, unit_id, depth_list, confidence_list, max_zoom, custom_restricted_api)
VALUES ((json_data->>'property')::character varying, (json_data->>'indicator_id')::integer, (json_data->>'scale_factor')::real, (json_data->>'no_data')::integer, (json_data->>'details')::character varying, (json_data->>'qml')::character varying, (json_data->>'sld')::character varying, (json_data->>'file_name')::character varying, (json_data->>'color_map')::text, (json_data->>'unit_id')::integer, (json_data->>'depth_list')::character varying, (json_data->>'confidence_list')::character varying, (json_data->>'max_zoom')::integer, (json_data->>'custom_restricted_api')::json)
RETURNING id INTO v_id;
RETURN v_id;
END $function$
*/
}
/**
* @function data_shdc_d
* @memberof zzglc
* @description Data shdc d
* @param {integer} Key
* @returns {void}
*/
function data_shdc_d() {
/*
CREATE OR REPLACE FUNCTION zzglc.data_shdc_d("Key" integer)
RETURNS void
LANGUAGE plpgsql
AS $function$
BEGIN
DELETE FROM data.shdc WHERE id = "Key";
END;
$function$
*/
}
/**
* @function data_shdc_file_c
* @memberof zzglc
* @description Data shdc file c
* @param {character_varying} Json
* @returns {integer}
*/
function data_shdc_file_c() {
/*
CREATE OR REPLACE FUNCTION zzglc.data_shdc_file_c("Json" character varying)
RETURNS integer
LANGUAGE plpgsql
AS $function$
DECLARE v_id integer;
DECLARE json_data json;
BEGIN
json_data := "Json";
INSERT INTO data.shdc_file (file_name, shdc_id, depth_id, temporal_coverage_start, temporal_coverage_end, value, wasabi_link, description)
VALUES ((json_data->>'file_name')::character varying, (json_data->>'shdc_id')::integer, (json_data->>'depth_id')::integer, (json_data->>'temporal_coverage_start')::character varying, (json_data->>'temporal_coverage_end')::character varying, (json_data->>'value')::character varying, (json_data->>'wasabi_link')::character varying, (json_data->>'description')::text)
RETURNING id INTO v_id;
RETURN v_id;
END $function$
*/
}
/**
* @function data_shdc_file_d
* @memberof zzglc
* @description Data shdc file d
* @param {integer} Key
* @returns {void}
*/
function data_shdc_file_d() {
/*
CREATE OR REPLACE FUNCTION zzglc.data_shdc_file_d("Key" integer)
RETURNS void
LANGUAGE plpgsql
AS $function$
BEGIN
DELETE FROM data.shdc_file WHERE id = "Key";
END;
$function$
*/
}
/**
* @function data_shdc_file_r
* @memberof zzglc
* @description Data shdc file r
* @param {integer} Key
* @returns {Object} integer idcharacter_varying file_nameinteger data_shdc__shdc_idinteger data_depth__depth_idcharacter_varying temporal_coverage_startcharacter_varying temporal_coverage_endcharacter_varying valuecharacter_varying wasabi_linktext descriptioncharacter_varying data_shdc__shdc_id_valcharacter_varying data_depth__depth_id_val
*/
function data_shdc_file_r() {
/*
CREATE OR REPLACE FUNCTION zzglc.data_shdc_file_r("Key" integer)
RETURNS TABLE(id integer, file_name character varying, data_shdc__shdc_id integer, data_depth__depth_id integer, temporal_coverage_start character varying, temporal_coverage_end character varying, value character varying, wasabi_link character varying, description text, data_shdc__shdc_id_val character varying, data_depth__depth_id_val character varying)
LANGUAGE plpgsql
AS $function$
BEGIN
RETURN QUERY (
SELECT t.id, t.file_name, t.shdc_id, t.depth_id, t.temporal_coverage_start, t.temporal_coverage_end, t.value, t.wasabi_link, t.description, shdc_id.property, depth_id.name
FROM data.shdc_file t
LEFT JOIN data.shdc shdc_id ON shdc_id.id = t.shdc_id
LEFT JOIN data.depth depth_id ON depth_id.id = t.depth_id
WHERE t.shdc_id = "Key"
ORDER BY 2
);
END $function$
*/
}
/**
* @function data_shdc_file_r_overload
* @overload data_shdc_file_r
* @memberof zzglc
* @description Data shdc file r
* @returns {Object} integer idcharacter_varying file_nameinteger data_shdc__shdc_idinteger data_depth__depth_idcharacter_varying temporal_coverage_startcharacter_varying temporal_coverage_endcharacter_varying valuecharacter_varying wasabi_linktext descriptioncharacter_varying data_shdc__shdc_id_valcharacter_varying data_depth__depth_id_val
*/
function data_shdc_file_r_overload() {
/*
CREATE OR REPLACE FUNCTION zzglc.data_shdc_file_r()
RETURNS TABLE(id integer, file_name character varying, data_shdc__shdc_id integer, data_depth__depth_id integer, temporal_coverage_start character varying, temporal_coverage_end character varying, value character varying, wasabi_link character varying, description text, data_shdc__shdc_id_val character varying, data_depth__depth_id_val character varying)
LANGUAGE plpgsql
AS $function$
BEGIN
RETURN QUERY (
SELECT t.id, t.file_name, t.shdc_id, t.depth_id, t.temporal_coverage_start, t.temporal_coverage_end, t.value, t.wasabi_link, t.description, shdc_id.property, depth_id.name
FROM data.shdc_file t
LEFT JOIN data.shdc shdc_id ON shdc_id.id = t.shdc_id
LEFT JOIN data.depth depth_id ON depth_id.id = t.depth_id
ORDER BY 2
);
END $function$
*/
}
/**
* @function data_shdc_file_u
* @memberof zzglc
* @description Data shdc file u
* @param {character_varying} Json
* @returns {integer}
*/
function data_shdc_file_u() {
/*
CREATE OR REPLACE FUNCTION zzglc.data_shdc_file_u("Json" character varying)
RETURNS integer
LANGUAGE plpgsql
AS $function$
DECLARE v_id integer;
DECLARE json_data json;
BEGIN
json_data := "Json";
v_id := (json_data->>'id')::integer;
UPDATE data.shdc_file SET
file_name = (json_data->>'file_name')::character varying,
shdc_id = (json_data->>'shdc_id')::integer,
depth_id = (json_data->>'depth_id')::integer,
temporal_coverage_start = (json_data->>'temporal_coverage_start')::character varying,
temporal_coverage_end = (json_data->>'temporal_coverage_end')::character varying,
value = (json_data->>'value')::character varying,
wasabi_link = (json_data->>'wasabi_link')::character varying,
description = (json_data->>'description')::text
WHERE id = v_id;
RETURN v_id;
END $function$
*/
}
/**
* @function data_shdc_property_c
* @memberof zzglc
* @description Data shdc property c
* @param {character_varying} Json
* @returns {integer}
*/
function data_shdc_property_c() {
/*
CREATE OR REPLACE FUNCTION zzglc.data_shdc_property_c("Json" character varying)
RETURNS integer
LANGUAGE plpgsql
AS $function$
DECLARE v_id integer;
DECLARE json_data json;
BEGIN
json_data := "Json";
INSERT INTO data.shdc_property (property, indicator_id)
VALUES ((json_data->>'property')::character varying, (json_data->>'indicator_id')::integer)
RETURNING id INTO v_id;
RETURN v_id;
END $function$
*/
}
/**
* @function data_shdc_property_d
* @memberof zzglc
* @description Data shdc property d
* @param {integer} Key
* @returns {void}
*/
function data_shdc_property_d() {
/*
CREATE OR REPLACE FUNCTION zzglc.data_shdc_property_d("Key" integer)
RETURNS void
LANGUAGE plpgsql
AS $function$
BEGIN
DELETE FROM data.shdc_property WHERE id = "Key";
END;
$function$
*/
}
/**
* @function data_shdc_property_r
* @memberof zzglc
* @description Data shdc property r
* @returns {Object} integer idcharacter_varying propertyinteger data_indicator__indicator_idcharacter_varying data_indicator__indicator_id_val
*/
function data_shdc_property_r() {
/*
CREATE OR REPLACE FUNCTION zzglc.data_shdc_property_r()
RETURNS TABLE(id integer, property character varying, data_indicator__indicator_id integer, data_indicator__indicator_id_val character varying)
LANGUAGE plpgsql
AS $function$
BEGIN
RETURN QUERY (
SELECT t.id, t.property, t.indicator_id, indicator_id.name
FROM data.shdc_property t
LEFT JOIN data.indicator indicator_id ON indicator_id.id = t.indicator_id
ORDER BY 2
);
END $function$
*/
}
/**
* @function data_shdc_property_u
* @memberof zzglc
* @description Data shdc property u
* @param {character_varying} Json
* @returns {void}
*/
function data_shdc_property_u() {
/*
CREATE OR REPLACE FUNCTION zzglc.data_shdc_property_u("Json" character varying)
RETURNS void
LANGUAGE plpgsql
AS $function$
DECLARE json_data json;
BEGIN
json_data := "Json";
UPDATE data.shdc_property SET
property = (json_data->>'property')::character varying,
indicator_id = (json_data->>'indicator_id')::integer
WHERE id = (json_data->>'id')::integer;
END $function$
*/
}
/**
* @function data_shdc_r
* @memberof zzglc
* @description Data shdc r
* @returns {Object} integer idcharacter_varying propertyinteger data_indicator__indicator_idreal scale_factorinteger no_datacharacter_varying detailscharacter_varying qmlcharacter_varying sldcharacter_varying file_nametext color_mapinteger catalog_unit__unit_idcharacter_varying depth_listcharacter_varying confidence_listinteger max_zoomjson custom_restricted_apicharacter_varying data_indicator__indicator_id_valcharacter_varying catalog_unit__unit_id_val
*/
function data_shdc_r() {
/*
CREATE OR REPLACE FUNCTION zzglc.data_shdc_r()
RETURNS TABLE(id integer, property character varying, data_indicator__indicator_id integer, scale_factor real, no_data integer, details character varying, qml character varying, sld character varying, file_name character varying, color_map text, catalog_unit__unit_id integer, depth_list character varying, confidence_list character varying, max_zoom integer, custom_restricted_api json, data_indicator__indicator_id_val character varying, catalog_unit__unit_id_val character varying)
LANGUAGE plpgsql
AS $function$
BEGIN
RETURN QUERY (
SELECT t.id, t.property, t.indicator_id, t.scale_factor, t.no_data, t.details, t.qml, t.sld, t.file_name, t.color_map, t.unit_id, t.depth_list, t.confidence_list, t.max_zoom, t.custom_restricted_api, indicator_id.display_name, unit_id.display_name
FROM data.shdc t
LEFT JOIN data.indicator indicator_id ON indicator_id.id = t.indicator_id
LEFT JOIN catalog.unit unit_id ON unit_id.id = t.unit_id
ORDER BY 2
);
END $function$
*/
}
/**
* @function data_shdc_u
* @memberof zzglc
* @description Data shdc u
* @param {character_varying} Json
* @returns {integer}
*/
function data_shdc_u() {
/*
CREATE OR REPLACE FUNCTION zzglc.data_shdc_u("Json" character varying)
RETURNS integer
LANGUAGE plpgsql
AS $function$
DECLARE v_id integer;
DECLARE json_data json;
BEGIN
json_data := "Json";
v_id := (json_data->>'id')::integer;
UPDATE data.shdc SET
property = (json_data->>'property')::character varying,
indicator_id = (json_data->>'indicator_id')::integer,
scale_factor = (json_data->>'scale_factor')::real,
no_data = (json_data->>'no_data')::integer,
details = (json_data->>'details')::character varying,
qml = (json_data->>'qml')::character varying,
sld = (json_data->>'sld')::character varying,
file_name = (json_data->>'file_name')::character varying,
color_map = (json_data->>'color_map')::text,
unit_id = (json_data->>'unit_id')::integer,
depth_list = (json_data->>'depth_list')::character varying,
confidence_list = (json_data->>'confidence_list')::character varying,
max_zoom = (json_data->>'max_zoom')::integer,
custom_restricted_api = (json_data->>'custom_restricted_api')::json
WHERE id = v_id;
RETURN v_id;
END $function$
*/
}
/**
* @function data_site_c
* @memberof zzglc
* @description Data site c
* @param {character_varying} Json
* @returns {integer}
*/
function data_site_c() {
/*
CREATE OR REPLACE FUNCTION zzglc.data_site_c("Json" character varying)
RETURNS integer
LANGUAGE plpgsql
AS $function$
DECLARE v_id integer;
DECLARE json_data json;
BEGIN
json_data := "Json";
INSERT INTO data.site (name, data_source_id, person_id, description, url)
VALUES ((json_data->>'name')::character varying, (json_data->>'data_source_id')::integer, auth.get_context_person_id(), (json_data->>'description')::text, (json_data->>'url')::character varying)
RETURNING id INTO v_id;
RETURN v_id;
END $function$
*/
}
/**
* @function data_site_d
* @memberof zzglc
* @description Data site d
* @param {integer} Key
* @returns {void}
*/
function data_site_d() {
/*
CREATE OR REPLACE FUNCTION zzglc.data_site_d("Key" integer)
RETURNS void
LANGUAGE plpgsql
AS $function$
BEGIN
DELETE FROM data.site WHERE id = "Key";
END;
$function$
*/
}
/**
* @function data_site_r
* @memberof zzglc
* @description Data site r
* @param {integer} Key
* @returns {Object} integer idcharacter_varying nameinteger data_data_source__data_source_idinteger auth_person__person_idtext descriptioncharacter_varying urlcharacter_varying data_data_source__data_source_id_valcharacter_varying auth_person__person_id_val
*/
function data_site_r() {
/*
CREATE OR REPLACE FUNCTION zzglc.data_site_r("Key" integer)
RETURNS TABLE(id integer, name character varying, data_data_source__data_source_id integer, auth_person__person_id integer, description text, url character varying, data_data_source__data_source_id_val character varying, auth_person__person_id_val character varying)
LANGUAGE plpgsql
AS $function$
BEGIN
RETURN QUERY (
SELECT t.id, t.name, t.data_source_id, t.person_id, t.description, t.url, data_source_id.name, person_id.email
FROM data.site t
LEFT JOIN auth.vw_partner vwp ON vwp.user_id = t.person_id AND vwp.partner_user_id = auth.get_context_person_id()
LEFT JOIN data.data_source data_source_id ON data_source_id.id = t.data_source_id
LEFT JOIN auth.person person_id ON person_id.id = t.person_id
WHERE t.data_source_id = "Key"
ORDER BY 2
);
END $function$
*/
}
/**
* @function data_site_r_overload
* @overload data_site_r
* @memberof zzglc
* @description Data site r
* @returns {Object} integer idcharacter_varying nameinteger data_data_source__data_source_idinteger auth_person__person_idtext descriptioncharacter_varying urlcharacter_varying data_data_source__data_source_id_valcharacter_varying auth_person__person_id_val
*/
function data_site_r_overload() {
/*
CREATE OR REPLACE FUNCTION zzglc.data_site_r()
RETURNS TABLE(id integer, name character varying, data_data_source__data_source_id integer, auth_person__person_id integer, description text, url character varying, data_data_source__data_source_id_val character varying, auth_person__person_id_val character varying)
LANGUAGE plpgsql
AS $function$
BEGIN
RETURN QUERY (
SELECT t.id, t.name, t.data_source_id, t.person_id, t.description, t.url, data_source_id.name, person_id.email
FROM data.site t
LEFT JOIN auth.vw_partner vwp ON vwp.user_id = t.person_id AND vwp.partner_user_id = auth.get_context_person_id()
LEFT JOIN data.data_source data_source_id ON data_source_id.id = t.data_source_id
LEFT JOIN auth.person person_id ON person_id.id = t.person_id
WHERE vwp.user_id = auth.get_context_person_id() OR auth.get_context_is_admin()
ORDER BY 2
);
END $function$
*/
}
/**
* @function data_site_sampling_checklist_c
* @memberof zzglc
* @description Data site sampling checklist c
* @param {character_varying} Json
* @returns {integer}
*/
function data_site_sampling_checklist_c() {
/*
CREATE OR REPLACE FUNCTION zzglc.data_site_sampling_checklist_c("Json" character varying)
RETURNS integer
LANGUAGE plpgsql
AS $function$
DECLARE v_id integer;
DECLARE json_data json;
BEGIN
json_data := "Json";
INSERT INTO data.site_sampling_checklist (site_id, wet_chemistry, edna, macrofauna, microbiometer, moulder, fieldobs, soil_spectra_no, soil_spectra_mx, soil_spectra_ds, penetrometer_npkphcth, enzymes, ise_ph, infiltration)
VALUES ((json_data->>'site_id')::integer, (json_data->>'wet_chemistry')::boolean, (json_data->>'edna')::boolean, (json_data->>'macrofauna')::boolean, (json_data->>'microbiometer')::boolean, (json_data->>'moulder')::boolean, (json_data->>'fieldobs')::boolean, (json_data->>'soil_spectra_no')::boolean, (json_data->>'soil_spectra_mx')::boolean, (json_data->>'soil_spectra_ds')::boolean, (json_data->>'penetrometer_npkphcth')::boolean, (json_data->>'enzymes')::boolean, (json_data->>'ise_ph')::boolean, (json_data->>'infiltration')::boolean)
RETURNING id INTO v_id;
RETURN v_id;
END $function$
*/
}
/**
* @function data_site_sampling_checklist_d
* @memberof zzglc
* @description Data site sampling checklist d
* @param {integer} Key
* @returns {void}
*/
function data_site_sampling_checklist_d() {
/*
CREATE OR REPLACE FUNCTION zzglc.data_site_sampling_checklist_d("Key" integer)
RETURNS void
LANGUAGE plpgsql
AS $function$
BEGIN
DELETE FROM data.site_sampling_checklist WHERE id = "Key";
END;
$function$
*/
}
/**
* @function data_site_sampling_checklist_r
* @memberof zzglc
* @description Data site sampling checklist r
* @param {integer} Key
* @returns {Object} integer idinteger data_site__site_idboolean wet_chemistryboolean ednaboolean macrofaunaboolean microbiometerboolean moulderboolean fieldobsboolean soil_spectra_noboolean soil_spectra_mxboolean soil_spectra_dsboolean penetrometer_npkphcthboolean enzymesboolean ise_phboolean infiltrationcharacter_varying data_site__site_id_val
*/
function data_site_sampling_checklist_r() {
/*
CREATE OR REPLACE FUNCTION zzglc.data_site_sampling_checklist_r("Key" integer)
RETURNS TABLE(id integer, data_site__site_id integer, wet_chemistry boolean, edna boolean, macrofauna boolean, microbiometer boolean, moulder boolean, fieldobs boolean, soil_spectra_no boolean, soil_spectra_mx boolean, soil_spectra_ds boolean, penetrometer_npkphcth boolean, enzymes boolean, ise_ph boolean, infiltration boolean, data_site__site_id_val character varying)
LANGUAGE plpgsql
AS $function$
BEGIN
RETURN QUERY (
SELECT t.id, t.site_id, t.wet_chemistry, t.edna, t.macrofauna, t.microbiometer, t.moulder, t.fieldobs, t.soil_spectra_no, t.soil_spectra_mx, t.soil_spectra_ds, t.penetrometer_npkphcth, t.enzymes, t.ise_ph, t.infiltration, site_id.name
FROM data.site_sampling_checklist t
LEFT JOIN data.site site_id ON site_id.id = t.site_id
WHERE t.site_id = "Key"
ORDER BY 2
);
END $function$
*/
}
/**
* @function data_site_sampling_checklist_r_overload
* @overload data_site_sampling_checklist_r
* @memberof zzglc
* @description Data site sampling checklist r
* @returns {Object} integer idinteger data_site__site_idboolean wet_chemistryboolean ednaboolean macrofaunaboolean microbiometerboolean moulderboolean fieldobsboolean soil_spectra_noboolean soil_spectra_mxboolean soil_spectra_dsboolean penetrometer_npkphcthboolean enzymesboolean ise_phboolean infiltrationcharacter_varying data_site__site_id_val
*/
function data_site_sampling_checklist_r_overload() {
/*
CREATE OR REPLACE FUNCTION zzglc.data_site_sampling_checklist_r()
RETURNS TABLE(id integer, data_site__site_id integer, wet_chemistry boolean, edna boolean, macrofauna boolean, microbiometer boolean, moulder boolean, fieldobs boolean, soil_spectra_no boolean, soil_spectra_mx boolean, soil_spectra_ds boolean, penetrometer_npkphcth boolean, enzymes boolean, ise_ph boolean, infiltration boolean, data_site__site_id_val character varying)
LANGUAGE plpgsql
AS $function$
BEGIN
RETURN QUERY (
SELECT t.id, t.site_id, t.wet_chemistry, t.edna, t.macrofauna, t.microbiometer, t.moulder, t.fieldobs, t.soil_spectra_no, t.soil_spectra_mx, t.soil_spectra_ds, t.penetrometer_npkphcth, t.enzymes, t.ise_ph, t.infiltration, site_id.name
FROM data.site_sampling_checklist t
LEFT JOIN data.site site_id ON site_id.id = t.site_id
ORDER BY 2
);
END $function$
*/
}
/**
* @function data_site_sampling_checklist_s_r
* @memberof zzglc
* @description Data site sampling checklist s r
* @param {integer} Key
* @returns {Object} integer idinteger data_site__site_idboolean wet_chemistryboolean ednaboolean macrofaunaboolean microbiometerboolean moulderboolean fieldobsboolean soil_spectra_noboolean soil_spectra_mxboolean soil_spectra_dsboolean penetrometer_npkphcthboolean enzymesboolean ise_phboolean infiltrationcharacter_varying data_site__site_id_val
*/
function data_site_sampling_checklist_s_r() {
/*
CREATE OR REPLACE FUNCTION zzglc.data_site_sampling_checklist_s_r("Key" integer)
RETURNS TABLE(id integer, data_site__site_id integer, wet_chemistry boolean, edna boolean, macrofauna boolean, microbiometer boolean, moulder boolean, fieldobs boolean, soil_spectra_no boolean, soil_spectra_mx boolean, soil_spectra_ds boolean, penetrometer_npkphcth boolean, enzymes boolean, ise_ph boolean, infiltration boolean, data_site__site_id_val character varying)
LANGUAGE plpgsql
AS $function$
BEGIN
RETURN QUERY (
SELECT t.id, t.site_id, t.wet_chemistry, t.edna, t.macrofauna, t.microbiometer, t.moulder, t.fieldobs, t.soil_spectra_no, t.soil_spectra_mx, t.soil_spectra_ds, t.penetrometer_npkphcth, t.enzymes, t.ise_ph, t.infiltration, site_id.name
FROM data.site_sampling_checklist t
LEFT JOIN data.site site_id ON site_id.id = t.site_id
WHERE t.id = "Key"
ORDER BY 2
);
END $function$
*/
}
/**
* @function data_site_sampling_checklist_u
* @memberof zzglc
* @description Data site sampling checklist u
* @param {character_varying} Json
* @returns {void}
*/
function data_site_sampling_checklist_u() {
/*
CREATE OR REPLACE FUNCTION zzglc.data_site_sampling_checklist_u("Json" character varying)
RETURNS void
LANGUAGE plpgsql
AS $function$
DECLARE json_data json;
BEGIN
json_data := "Json";
UPDATE data.site_sampling_checklist SET
site_id = (json_data->>'site_id')::integer,
wet_chemistry = (json_data->>'wet_chemistry')::boolean,
edna = (json_data->>'edna')::boolean,
macrofauna = (json_data->>'macrofauna')::boolean,
microbiometer = (json_data->>'microbiometer')::boolean,
moulder = (json_data->>'moulder')::boolean,
fieldobs = (json_data->>'fieldobs')::boolean,
soil_spectra_no = (json_data->>'soil_spectra_no')::boolean,
soil_spectra_mx = (json_data->>'soil_spectra_mx')::boolean,
soil_spectra_ds = (json_data->>'soil_spectra_ds')::boolean,
penetrometer_npkphcth = (json_data->>'penetrometer_npkphcth')::boolean,
enzymes = (json_data->>'enzymes')::boolean,
ise_ph = (json_data->>'ise_ph')::boolean,
infiltration = (json_data->>'infiltration')::boolean
WHERE id = (json_data->>'id')::integer;
END $function$
*/
}
/**
* @function data_site_u
* @memberof zzglc
* @description Data site u
* @param {character_varying} Json
* @returns {integer}
*/
function data_site_u() {
/*
CREATE OR REPLACE FUNCTION zzglc.data_site_u("Json" character varying)
RETURNS integer
LANGUAGE plpgsql
AS $function$
DECLARE v_id integer;
DECLARE json_data json;
BEGIN
json_data := "Json";
v_id := (json_data->>'id')::integer;
UPDATE data.site SET
name = (json_data->>'name')::character varying,
data_source_id = (json_data->>'data_source_id')::integer,
person_id = (json_data->>'person_id')::integer,
description = (json_data->>'description')::text,
url = (json_data->>'url')::character varying
WHERE id = v_id;
RETURN v_id;
END $function$
*/
}
/**
* @function data_spectra_scan_c
* @memberof zzglc
* @description Data spectra scan c
* @param {character_varying} Json
* @returns {integer}
*/
function data_spectra_scan_c() {
/*
CREATE OR REPLACE FUNCTION zzglc.data_spectra_scan_c("Json" character varying)
RETURNS integer
LANGUAGE plpgsql
AS $function$
DECLARE v_id integer;
DECLARE json_data json;
BEGIN
json_data := "Json";
INSERT INTO data.spectra_scan (na_frequency, neg_frequency, ext_frequency, observation_id, spectroscopy_method_id, signal_mean, signal_stddev)
VALUES ((json_data->>'na_frequency')::real, (json_data->>'neg_frequency')::real, (json_data->>'ext_frequency')::real, (json_data->>'observation_id')::integer, (json_data->>'spectroscopy_method_id')::integer, (json_data->>'signal_mean')::real[], (json_data->>'signal_stddev')::real[])
RETURNING id INTO v_id;
RETURN v_id;
END $function$
*/
}
/**
* @function data_spectra_scan_d
* @memberof zzglc
* @description Data spectra scan d
* @param {integer} Key
* @returns {void}
*/
function data_spectra_scan_d() {
/*
CREATE OR REPLACE FUNCTION zzglc.data_spectra_scan_d("Key" integer)
RETURNS void
LANGUAGE plpgsql
AS $function$
BEGIN
DELETE FROM data.spectra_scan WHERE id = "Key";
END;
$function$
*/
}
/**
* @function data_spectra_scan_r
* @memberof zzglc
* @description Data spectra scan r
* @param {integer} Key
* @returns {Object} integer idreal na_frequencyreal neg_frequencyreal ext_frequencyinteger data_observation__observation_idinteger catalog_spectroscopy_method__spectroscopy_method_idreal[] signal_meanreal[] signal_stddevcharacter_varying data_observation__observation_id_valcharacter_varying catalog_spectroscopy_method__spectroscopy_method_id_val
*/
function data_spectra_scan_r() {
/*
CREATE OR REPLACE FUNCTION zzglc.data_spectra_scan_r("Key" integer)
RETURNS TABLE(id integer, na_frequency real, neg_frequency real, ext_frequency real, data_observation__observation_id integer, catalog_spectroscopy_method__spectroscopy_method_id integer, signal_mean real[], signal_stddev real[], data_observation__observation_id_val character varying, catalog_spectroscopy_method__spectroscopy_method_id_val character varying)
LANGUAGE plpgsql
AS $function$
BEGIN
RETURN QUERY (
SELECT t.id, t.na_frequency, t.neg_frequency, t.ext_frequency, t.observation_id, t.spectroscopy_method_id, t.signal_mean, t.signal_stddev, observation_id.comment, spectroscopy_method_id.name
FROM data.spectra_scan t
LEFT JOIN data.observation observation_id ON observation_id.id = t.observation_id
LEFT JOIN catalog.spectroscopy_method spectroscopy_method_id ON spectroscopy_method_id.id = t.spectroscopy_method_id
WHERE t.observation_id = "Key"
ORDER BY 2
);
END $function$
*/
}
/**
* @function data_spectra_scan_r_overload
* @overload data_spectra_scan_r
* @memberof zzglc
* @description Data spectra scan r
* @returns {Object} integer idreal na_frequencyreal neg_frequencyreal ext_frequencyinteger data_observation__observation_idinteger catalog_spectroscopy_method__spectroscopy_method_idreal[] signal_meanreal[] signal_stddevcharacter_varying data_observation__observation_id_valcharacter_varying catalog_spectroscopy_method__spectroscopy_method_id_val
*/
function data_spectra_scan_r_overload() {
/*
CREATE OR REPLACE FUNCTION zzglc.data_spectra_scan_r()
RETURNS TABLE(id integer, na_frequency real, neg_frequency real, ext_frequency real, data_observation__observation_id integer, catalog_spectroscopy_method__spectroscopy_method_id integer, signal_mean real[], signal_stddev real[], data_observation__observation_id_val character varying, catalog_spectroscopy_method__spectroscopy_method_id_val character varying)
LANGUAGE plpgsql
AS $function$
BEGIN
RETURN QUERY (
SELECT t.id, t.na_frequency, t.neg_frequency, t.ext_frequency, t.observation_id, t.spectroscopy_method_id, t.signal_mean, t.signal_stddev, observation_id.comment, spectroscopy_method_id.name
FROM data.spectra_scan t
LEFT JOIN data.observation observation_id ON observation_id.id = t.observation_id
LEFT JOIN catalog.spectroscopy_method spectroscopy_method_id ON spectroscopy_method_id.id = t.spectroscopy_method_id
ORDER BY 2
);
END $function$
*/
}
/**
* @function data_spectra_scan_u
* @memberof zzglc
* @description Data spectra scan u
* @param {character_varying} Json
* @returns {integer}
*/
function data_spectra_scan_u() {
/*
CREATE OR REPLACE FUNCTION zzglc.data_spectra_scan_u("Json" character varying)
RETURNS integer
LANGUAGE plpgsql
AS $function$
DECLARE v_id integer;
DECLARE json_data json;
BEGIN
json_data := "Json";
v_id := (json_data->>'id')::integer;
UPDATE data.spectra_scan SET
na_frequency = (json_data->>'na_frequency')::real,
neg_frequency = (json_data->>'neg_frequency')::real,
ext_frequency = (json_data->>'ext_frequency')::real,
observation_id = (json_data->>'observation_id')::integer,
spectroscopy_method_id = (json_data->>'spectroscopy_method_id')::integer,
signal_mean = (json_data->>'signal_mean')::real[],
signal_stddev = (json_data->>'signal_stddev')::real[]
WHERE id = v_id;
RETURN v_id;
END $function$
*/
}
/**
* @function data_spectrometer_c
* @memberof zzglc
* @description Data spectrometer c
* @param {character_varying} Json
* @returns {integer}
*/
function data_spectrometer_c() {
/*
CREATE OR REPLACE FUNCTION zzglc.data_spectrometer_c("Json" character varying)
RETURNS integer
LANGUAGE plpgsql
AS $function$
DECLARE v_id integer;
DECLARE json_data json;
BEGIN
json_data := "Json";
INSERT INTO data.spectrometer (wavelengths, equipment_id)
VALUES ((json_data->>'wavelengths')::real[], (json_data->>'equipment_id')::integer)
RETURNING id INTO v_id;
RETURN v_id;
END $function$
*/
}
/**
* @function data_spectrometer_d
* @memberof zzglc
* @description Data spectrometer d
* @param {integer} Key
* @returns {void}
*/
function data_spectrometer_d() {
/*
CREATE OR REPLACE FUNCTION zzglc.data_spectrometer_d("Key" integer)
RETURNS void
LANGUAGE plpgsql
AS $function$
BEGIN
DELETE FROM data.spectrometer WHERE id = "Key";
END;
$function$
*/
}
/**
* @function data_spectrometer_r
* @memberof zzglc
* @description Data spectrometer r
* @param {integer} Key
* @returns {Object} integer idreal[] wavelengthsinteger data_equipment__equipment_idcharacter_varying data_equipment__equipment_id_val
*/
function data_spectrometer_r() {
/*
CREATE OR REPLACE FUNCTION zzglc.data_spectrometer_r("Key" integer)
RETURNS TABLE(id integer, wavelengths real[], data_equipment__equipment_id integer, data_equipment__equipment_id_val character varying)
LANGUAGE plpgsql
AS $function$
BEGIN
RETURN QUERY (
SELECT t.id, t.wavelengths, t.equipment_id, equipment_id.model
FROM data.spectrometer t
LEFT JOIN data.equipment equipment_id ON equipment_id.id = t.equipment_id
WHERE t.equipment_id = "Key"
ORDER BY 2
);
END $function$
*/
}
/**
* @function data_spectrometer_r_overload
* @overload data_spectrometer_r
* @memberof zzglc
* @description Data spectrometer r
* @returns {Object} integer idreal[] wavelengthsinteger data_equipment__equipment_idcharacter_varying data_equipment__equipment_id_val
*/
function data_spectrometer_r_overload() {
/*
CREATE OR REPLACE FUNCTION zzglc.data_spectrometer_r()
RETURNS TABLE(id integer, wavelengths real[], data_equipment__equipment_id integer, data_equipment__equipment_id_val character varying)
LANGUAGE plpgsql
AS $function$
BEGIN
RETURN QUERY (
SELECT t.id, t.wavelengths, t.equipment_id, equipment_id.model
FROM data.spectrometer t
LEFT JOIN data.equipment equipment_id ON equipment_id.id = t.equipment_id
ORDER BY 2
);
END $function$
*/
}
/**
* @function data_spectrometer_u
* @memberof zzglc
* @description Data spectrometer u
* @param {character_varying} Json
* @returns {integer}
*/
function data_spectrometer_u() {
/*
CREATE OR REPLACE FUNCTION zzglc.data_spectrometer_u("Json" character varying)
RETURNS integer
LANGUAGE plpgsql
AS $function$
DECLARE v_id integer;
DECLARE json_data json;
BEGIN
json_data := "Json";
v_id := (json_data->>'id')::integer;
UPDATE data.spectrometer SET
wavelengths = (json_data->>'wavelengths')::real[],
equipment_id = (json_data->>'equipment_id')::integer
WHERE id = v_id;
IF NOT FOUND THEN
INSERT INTO data.spectrometer (wavelengths, equipment_id)
VALUES ((json_data->>'wavelengths')::real[], (json_data->>'equipment_id')::integer)
RETURNING id INTO v_id;
END IF;
RETURN v_id;
END $function$
*/
}
/**
* @function data_taxa_c
* @memberof zzglc
* @description Data taxa c
* @param {character_varying} Json
* @returns {integer}
*/
function data_taxa_c() {
/*
CREATE OR REPLACE FUNCTION zzglc.data_taxa_c("Json" character varying)
RETURNS integer
LANGUAGE plpgsql
AS $function$
DECLARE v_id integer;
DECLARE json_data json;
BEGIN
json_data := "Json";
INSERT INTO data.taxa (name, latin_name, taxa_level_id, taxa_status_id, taxa_code_id, link, remarks, reference, vern, env, chrono, parent_id, synonym, uncertain, extinct, id_text)
VALUES ((json_data->>'name')::character varying, (json_data->>'latin_name')::citext, (json_data->>'taxa_level_id')::integer, (json_data->>'taxa_status_id')::integer, (json_data->>'taxa_code_id')::integer, (json_data->>'link')::character varying, (json_data->>'remarks')::character varying, (json_data->>'reference')::character varying, (json_data->>'vern')::character varying, (json_data->>'env')::character varying, (json_data->>'chrono')::character varying, (json_data->>'parent_id')::integer, (json_data->>'synonym')::boolean, (json_data->>'uncertain')::boolean, (json_data->>'extinct')::boolean, (json_data->>'id_text')::character varying)
RETURNING id INTO v_id;
RETURN v_id;
END $function$
*/
}
/**
* @function data_taxa_d
* @memberof zzglc
* @description Data taxa d
* @param {integer} Key
* @returns {void}
*/
function data_taxa_d() {
/*
CREATE OR REPLACE FUNCTION zzglc.data_taxa_d("Key" integer)
RETURNS void
LANGUAGE plpgsql
AS $function$
BEGIN
DELETE FROM data.taxa WHERE id = "Key";
END;
$function$
*/
}
/**
* @function data_taxa_function_c
* @memberof zzglc
* @description Data taxa function c
* @param {character_varying} Json
* @returns {integer}
*/
function data_taxa_function_c() {
/*
CREATE OR REPLACE FUNCTION zzglc.data_taxa_function_c("Json" character varying)
RETURNS integer
LANGUAGE plpgsql
AS $function$
DECLARE v_id integer;
DECLARE json_data json;
BEGIN
json_data := "Json";
INSERT INTO data.taxa_function (name, taxa_status_id)
VALUES ((json_data->>'name')::character varying, (json_data->>'taxa_status_id')::integer)
RETURNING id INTO v_id;
RETURN v_id;
END $function$
*/
}
/**
* @function data_taxa_function_d
* @memberof zzglc
* @description Data taxa function d
* @param {integer} Key
* @returns {void}
*/
function data_taxa_function_d() {
/*
CREATE OR REPLACE FUNCTION zzglc.data_taxa_function_d("Key" integer)
RETURNS void
LANGUAGE plpgsql
AS $function$
BEGIN
DELETE FROM data.taxa_function WHERE id = "Key";
END;
$function$
*/
}
/**
* @function data_taxa_function_r
* @memberof zzglc
* @description Data taxa function r
* @returns {Object} integer idcharacter_varying nameinteger catalog_taxa_status__taxa_status_idcharacter_varying catalog_taxa_status__taxa_status_id_val
*/
function data_taxa_function_r() {
/*
CREATE OR REPLACE FUNCTION zzglc.data_taxa_function_r()
RETURNS TABLE(id integer, name character varying, catalog_taxa_status__taxa_status_id integer, catalog_taxa_status__taxa_status_id_val character varying)
LANGUAGE plpgsql
AS $function$
BEGIN
RETURN QUERY (
SELECT t.id, t.name, t.taxa_status_id, taxa_status_id.name
FROM data.taxa_function t
LEFT JOIN catalog.taxa_status taxa_status_id ON taxa_status_id.id = t.taxa_status_id
ORDER BY 2
);
END $function$
*/
}
/**
* @function data_taxa_function_u
* @memberof zzglc
* @description Data taxa function u
* @param {character_varying} Json
* @returns {integer}
*/
function data_taxa_function_u() {
/*
CREATE OR REPLACE FUNCTION zzglc.data_taxa_function_u("Json" character varying)
RETURNS integer
LANGUAGE plpgsql
AS $function$
DECLARE v_id integer;
DECLARE json_data json;
BEGIN
json_data := "Json";
v_id := (json_data->>'id')::integer;
UPDATE data.taxa_function SET
name = (json_data->>'name')::character varying,
taxa_status_id = (json_data->>'taxa_status_id')::integer
WHERE id = v_id;
RETURN v_id;
END $function$
*/
}
/**
* @function data_taxa_heterogeneity_c
* @memberof zzglc
* @description Data taxa heterogeneity c
* @param {character_varying} Json
* @returns {integer}
*/
function data_taxa_heterogeneity_c() {
/*
CREATE OR REPLACE FUNCTION zzglc.data_taxa_heterogeneity_c("Json" character varying)
RETURNS integer
LANGUAGE plpgsql
AS $function$
DECLARE v_id integer;
DECLARE json_data json;
BEGIN
json_data := "Json";
INSERT INTO data.taxa_heterogeneity (edna_id, barcoding_pipeline_id, bioinformatic_treatment_date, taxa_id, richness, shannon, abundance, sequence_reference_id, bioinformatic_treatment_id)
VALUES ((json_data->>'edna_id')::integer, (json_data->>'barcoding_pipeline_id')::integer, (json_data->>'bioinformatic_treatment_date')::timestamp with time zone, (json_data->>'taxa_id')::integer, (json_data->>'richness')::double precision, (json_data->>'shannon')::double precision, (json_data->>'abundance')::double precision, (json_data->>'sequence_reference_id')::integer, (json_data->>'bioinformatic_treatment_id')::integer)
RETURNING id INTO v_id;
RETURN v_id;
END $function$
*/
}
/**
* @function data_taxa_heterogeneity_d
* @memberof zzglc
* @description Data taxa heterogeneity d
* @param {integer} Key
* @returns {void}
*/
function data_taxa_heterogeneity_d() {
/*
CREATE OR REPLACE FUNCTION zzglc.data_taxa_heterogeneity_d("Key" integer)
RETURNS void
LANGUAGE plpgsql
AS $function$
BEGIN
DELETE FROM data.taxa_heterogeneity WHERE id = "Key";
END;
$function$
*/
}
/**
* @function data_taxa_heterogeneity_function_c
* @memberof zzglc
* @description Data taxa heterogeneity function c
* @param {character_varying} Json
* @returns {integer}
*/
function data_taxa_heterogeneity_function_c() {
/*
CREATE OR REPLACE FUNCTION zzglc.data_taxa_heterogeneity_function_c("Json" character varying)
RETURNS integer
LANGUAGE plpgsql
AS $function$
DECLARE v_id integer;
DECLARE json_data json;
BEGIN
json_data := "Json";
INSERT INTO data.taxa_heterogeneity_function (taxa_heterogeneity_id, taxa_function_id, info, quantity)
VALUES ((json_data->>'taxa_heterogeneity_id')::integer, (json_data->>'taxa_function_id')::integer, (json_data->>'info')::character varying, (json_data->>'quantity')::double precision)
RETURNING id INTO v_id;
RETURN v_id;
END $function$
*/
}
/**
* @function data_taxa_heterogeneity_function_d
* @memberof zzglc
* @description Data taxa heterogeneity function d
* @param {integer} Key
* @returns {void}
*/
function data_taxa_heterogeneity_function_d() {
/*
CREATE OR REPLACE FUNCTION zzglc.data_taxa_heterogeneity_function_d("Key" integer)
RETURNS void
LANGUAGE plpgsql
AS $function$
BEGIN
DELETE FROM data.taxa_heterogeneity_function WHERE id = "Key";
END;
$function$
*/
}
/**
* @function data_taxa_heterogeneity_function_r
* @memberof zzglc
* @description Data taxa heterogeneity function r
* @param {integer} Key
* @returns {Object} integer idinteger data_taxa_heterogeneity__taxa_heterogeneity_idinteger data_taxa_function__taxa_function_idcharacter_varying infodouble_precision quantitycharacter_varying data_taxa_heterogeneity__taxa_heterogeneity_id_valcharacter_varying data_taxa_function__taxa_function_id_val
*/
function data_taxa_heterogeneity_function_r() {
/*
CREATE OR REPLACE FUNCTION zzglc.data_taxa_heterogeneity_function_r("Key" integer)
RETURNS TABLE(id integer, data_taxa_heterogeneity__taxa_heterogeneity_id integer, data_taxa_function__taxa_function_id integer, info character varying, quantity double precision, data_taxa_heterogeneity__taxa_heterogeneity_id_val character varying, data_taxa_function__taxa_function_id_val character varying)
LANGUAGE plpgsql
AS $function$
BEGIN
RETURN QUERY (
SELECT t.id, t.taxa_heterogeneity_id, t.taxa_function_id, t.info, t.quantity, taxa_heterogeneity_id.id::varchar, taxa_function_id.name
FROM data.taxa_heterogeneity_function t
LEFT JOIN data.taxa_heterogeneity taxa_heterogeneity_id ON taxa_heterogeneity_id.id = t.taxa_heterogeneity_id
LEFT JOIN data.taxa_function taxa_function_id ON taxa_function_id.id = t.taxa_function_id
WHERE t.taxa_heterogeneity_id = "Key"
ORDER BY 2
);
END $function$
*/
}
/**
* @function data_taxa_heterogeneity_function_r_overload
* @overload data_taxa_heterogeneity_function_r
* @memberof zzglc
* @description Data taxa heterogeneity function r
* @returns {Object} integer idinteger data_taxa_heterogeneity__taxa_heterogeneity_idinteger data_taxa_function__taxa_function_idcharacter_varying infodouble_precision quantitycharacter_varying data_taxa_heterogeneity__taxa_heterogeneity_id_valcharacter_varying data_taxa_function__taxa_function_id_val
*/
function data_taxa_heterogeneity_function_r_overload() {
/*
CREATE OR REPLACE FUNCTION zzglc.data_taxa_heterogeneity_function_r()
RETURNS TABLE(id integer, data_taxa_heterogeneity__taxa_heterogeneity_id integer, data_taxa_function__taxa_function_id integer, info character varying, quantity double precision, data_taxa_heterogeneity__taxa_heterogeneity_id_val character varying, data_taxa_function__taxa_function_id_val character varying)
LANGUAGE plpgsql
AS $function$
BEGIN
RETURN QUERY (
SELECT t.id, t.taxa_heterogeneity_id, t.taxa_function_id, t.info, t.quantity, taxa_heterogeneity_id.id::varchar, taxa_function_id.name
FROM data.taxa_heterogeneity_function t
LEFT JOIN data.taxa_heterogeneity taxa_heterogeneity_id ON taxa_heterogeneity_id.id = t.taxa_heterogeneity_id
LEFT JOIN data.taxa_function taxa_function_id ON taxa_function_id.id = t.taxa_function_id
ORDER BY 2
);
END $function$
*/
}
/**
* @function data_taxa_heterogeneity_function_u
* @memberof zzglc
* @description Data taxa heterogeneity function u
* @param {character_varying} Json
* @returns {integer}
*/
function data_taxa_heterogeneity_function_u() {
/*
CREATE OR REPLACE FUNCTION zzglc.data_taxa_heterogeneity_function_u("Json" character varying)
RETURNS integer
LANGUAGE plpgsql
AS $function$
DECLARE v_id integer;
DECLARE json_data json;
BEGIN
json_data := "Json";
v_id := (json_data->>'id')::integer;
UPDATE data.taxa_heterogeneity_function SET
taxa_heterogeneity_id = (json_data->>'taxa_heterogeneity_id')::integer,
taxa_function_id = (json_data->>'taxa_function_id')::integer,
info = (json_data->>'info')::character varying,
quantity = (json_data->>'quantity')::double precision
WHERE id = v_id;
RETURN v_id;
END $function$
*/
}
/**
* @function data_taxa_heterogeneity_r
* @memberof zzglc
* @description Data taxa heterogeneity r
* @param {integer} Key
* @returns {Object} integer idinteger data_edna__edna_idinteger barcoding_pipeline_idtimestamp_with_time_zone bioinformatic_treatment_dateinteger data_taxa__taxa_iddouble_precision richnessdouble_precision shannondouble_precision abundanceinteger catalog_sequence_reference_library__sequence_reference_idinteger data_bioinformatic_treatment__bioinformatic_treatment_idcharacter_varying data_edna__edna_id_valcharacter_varying data_taxa__taxa_id_valcharacter_varying catalog_sequence_reference_library__sequence_reference_id_valcharacter_varying data_bioinformatic_treatment__bioinformatic_treatment_id_val
*/
function data_taxa_heterogeneity_r() {
/*
CREATE OR REPLACE FUNCTION zzglc.data_taxa_heterogeneity_r("Key" integer)
RETURNS TABLE(id integer, data_edna__edna_id integer, barcoding_pipeline_id integer, bioinformatic_treatment_date timestamp with time zone, data_taxa__taxa_id integer, richness double precision, shannon double precision, abundance double precision, catalog_sequence_reference_library__sequence_reference_id integer, data_bioinformatic_treatment__bioinformatic_treatment_id integer, data_edna__edna_id_val character varying, data_taxa__taxa_id_val character varying, catalog_sequence_reference_library__sequence_reference_id_val character varying, data_bioinformatic_treatment__bioinformatic_treatment_id_val character varying)
LANGUAGE plpgsql
AS $function$
BEGIN
RETURN QUERY (
SELECT t.id, t.edna_id, t.barcoding_pipeline_id, t.bioinformatic_treatment_date, t.taxa_id, t.richness, t.shannon, t.abundance, t.sequence_reference_id, t.bioinformatic_treatment_id, edna_id.accession_code, taxa_id.name, sequence_reference_id.name, bioinformatic_treatment_id.name
FROM data.taxa_heterogeneity t
LEFT JOIN data.edna edna_id ON edna_id.id = t.edna_id
LEFT JOIN data.taxa taxa_id ON taxa_id.id = t.taxa_id
LEFT JOIN catalog.sequence_reference_library sequence_reference_id ON sequence_reference_id.id = t.sequence_reference_id
LEFT JOIN data.bioinformatic_treatment bioinformatic_treatment_id ON bioinformatic_treatment_id.id = t.bioinformatic_treatment_id
WHERE t.edna_id = "Key"
ORDER BY 2
);
END $function$
*/
}
/**
* @function data_taxa_heterogeneity_r_overload
* @overload data_taxa_heterogeneity_r
* @memberof zzglc
* @description Data taxa heterogeneity r
* @returns {Object} integer idinteger data_edna__edna_idinteger barcoding_pipeline_idtimestamp_with_time_zone bioinformatic_treatment_dateinteger data_taxa__taxa_iddouble_precision richnessdouble_precision shannondouble_precision abundanceinteger catalog_sequence_reference_library__sequence_reference_idinteger data_bioinformatic_treatment__bioinformatic_treatment_idcharacter_varying data_edna__edna_id_valcharacter_varying data_taxa__taxa_id_valcharacter_varying catalog_sequence_reference_library__sequence_reference_id_valcharacter_varying data_bioinformatic_treatment__bioinformatic_treatment_id_val
*/
function data_taxa_heterogeneity_r_overload() {
/*
CREATE OR REPLACE FUNCTION zzglc.data_taxa_heterogeneity_r()
RETURNS TABLE(id integer, data_edna__edna_id integer, barcoding_pipeline_id integer, bioinformatic_treatment_date timestamp with time zone, data_taxa__taxa_id integer, richness double precision, shannon double precision, abundance double precision, catalog_sequence_reference_library__sequence_reference_id integer, data_bioinformatic_treatment__bioinformatic_treatment_id integer, data_edna__edna_id_val character varying, data_taxa__taxa_id_val character varying, catalog_sequence_reference_library__sequence_reference_id_val character varying, data_bioinformatic_treatment__bioinformatic_treatment_id_val character varying)
LANGUAGE plpgsql
AS $function$
BEGIN
RETURN QUERY (
SELECT t.id, t.edna_id, t.barcoding_pipeline_id, t.bioinformatic_treatment_date, t.taxa_id, t.richness, t.shannon, t.abundance, t.sequence_reference_id, t.bioinformatic_treatment_id, edna_id.accession_code, taxa_id.name, sequence_reference_id.name, bioinformatic_treatment_id.name
FROM data.taxa_heterogeneity t
LEFT JOIN data.edna edna_id ON edna_id.id = t.edna_id
LEFT JOIN data.taxa taxa_id ON taxa_id.id = t.taxa_id
LEFT JOIN catalog.sequence_reference_library sequence_reference_id ON sequence_reference_id.id = t.sequence_reference_id
LEFT JOIN data.bioinformatic_treatment bioinformatic_treatment_id ON bioinformatic_treatment_id.id = t.bioinformatic_treatment_id
ORDER BY 2
);
END $function$
*/
}
/**
* @function data_taxa_heterogeneity_u
* @memberof zzglc
* @description Data taxa heterogeneity u
* @param {character_varying} Json
* @returns {integer}
*/
function data_taxa_heterogeneity_u() {
/*
CREATE OR REPLACE FUNCTION zzglc.data_taxa_heterogeneity_u("Json" character varying)
RETURNS integer
LANGUAGE plpgsql
AS $function$
DECLARE v_id integer;
DECLARE json_data json;
BEGIN
json_data := "Json";
v_id := (json_data->>'id')::integer;
UPDATE data.taxa_heterogeneity SET
edna_id = (json_data->>'edna_id')::integer,
barcoding_pipeline_id = (json_data->>'barcoding_pipeline_id')::integer,
bioinformatic_treatment_date = (json_data->>'bioinformatic_treatment_date')::timestamp with time zone,
taxa_id = (json_data->>'taxa_id')::integer,
richness = (json_data->>'richness')::double precision,
shannon = (json_data->>'shannon')::double precision,
abundance = (json_data->>'abundance')::double precision,
sequence_reference_id = (json_data->>'sequence_reference_id')::integer,
bioinformatic_treatment_id = (json_data->>'bioinformatic_treatment_id')::integer
WHERE id = v_id;
RETURN v_id;
END $function$
*/
}
/**
* @function data_taxa_r
* @memberof zzglc
* @description Data taxa r
* @returns {Object} integer idcharacter_varying namecitext latin_nameinteger taxa_level_idinteger taxa_status_idinteger taxa_code_idcharacter_varying linkcharacter_varying remarkscharacter_varying referencecharacter_varying verncharacter_varying envcharacter_varying chronointeger parent_idboolean synonymboolean uncertainboolean extinctcharacter_varying id_text
*/
function data_taxa_r() {
/*
CREATE OR REPLACE FUNCTION zzglc.data_taxa_r()
RETURNS TABLE(id integer, name character varying, latin_name citext, taxa_level_id integer, taxa_status_id integer, taxa_code_id integer, link character varying, remarks character varying, reference character varying, vern character varying, env character varying, chrono character varying, parent_id integer, synonym boolean, uncertain boolean, extinct boolean, id_text character varying)
LANGUAGE plpgsql
AS $function$
BEGIN
RETURN QUERY (
SELECT t.id, t.name, t.latin_name, t.taxa_level_id, t.taxa_status_id, t.taxa_code_id, t.link, t.remarks, t.reference, t.vern, t.env, t.chrono, t.parent_id, t.synonym, t.uncertain, t.extinct, t.id_text
FROM data.taxa t
ORDER BY 2
);
END $function$
*/
}
/**
* @function data_taxa_u
* @memberof zzglc
* @description Data taxa u
* @param {character_varying} Json
* @returns {integer}
*/
function data_taxa_u() {
/*
CREATE OR REPLACE FUNCTION zzglc.data_taxa_u("Json" character varying)
RETURNS integer
LANGUAGE plpgsql
AS $function$
DECLARE v_id integer;
DECLARE json_data json;
BEGIN
json_data := "Json";
v_id := (json_data->>'id')::integer;
UPDATE data.taxa SET
name = (json_data->>'name')::character varying,
latin_name = (json_data->>'latin_name')::citext,
taxa_level_id = (json_data->>'taxa_level_id')::integer,
taxa_status_id = (json_data->>'taxa_status_id')::integer,
taxa_code_id = (json_data->>'taxa_code_id')::integer,
link = (json_data->>'link')::character varying,
remarks = (json_data->>'remarks')::character varying,
reference = (json_data->>'reference')::character varying,
vern = (json_data->>'vern')::character varying,
env = (json_data->>'env')::character varying,
chrono = (json_data->>'chrono')::character varying,
parent_id = (json_data->>'parent_id')::integer,
synonym = (json_data->>'synonym')::boolean,
uncertain = (json_data->>'uncertain')::boolean,
extinct = (json_data->>'extinct')::boolean,
id_text = (json_data->>'id_text')::character varying
WHERE id = v_id;
RETURN v_id;
END $function$
*/
}
/**
* @function data_unit_conversion_c
* @memberof zzglc
* @description Data unit conversion c
* @param {character_varying} Json
* @returns {integer}
*/
function data_unit_conversion_c() {
/*
CREATE OR REPLACE FUNCTION zzglc.data_unit_conversion_c("Json" character varying)
RETURNS integer
LANGUAGE plpgsql
AS $function$
DECLARE v_id integer;
DECLARE json_data json;
BEGIN
json_data := "Json";
INSERT INTO data.unit_conversion (unit_from_id, unit_to_id, factor, add)
VALUES ((json_data->>'unit_from_id')::integer, (json_data->>'unit_to_id')::integer, (json_data->>'factor')::double precision, (json_data->>'add')::double precision)
RETURNING id INTO v_id;
RETURN v_id;
END $function$
*/
}
/**
* @function data_unit_conversion_d
* @memberof zzglc
* @description Data unit conversion d
* @param {integer} Key
* @returns {void}
*/
function data_unit_conversion_d() {
/*
CREATE OR REPLACE FUNCTION zzglc.data_unit_conversion_d("Key" integer)
RETURNS void
LANGUAGE plpgsql
AS $function$
BEGIN
DELETE FROM data.unit_conversion WHERE id = "Key";
END;
$function$
*/
}
/**
* @function data_unit_conversion_r
* @memberof zzglc
* @description Data unit conversion r
* @returns {Object} integer idinteger catalog_unit__unit_from_idinteger catalog_unit__unit_to_iddouble_precision factordouble_precision addcharacter_varying catalog_unit__unit_from_id_valcharacter_varying catalog_unit__unit_to_id_val
*/
function data_unit_conversion_r() {
/*
CREATE OR REPLACE FUNCTION zzglc.data_unit_conversion_r()
RETURNS TABLE(id integer, catalog_unit__unit_from_id integer, catalog_unit__unit_to_id integer, factor double precision, add double precision, catalog_unit__unit_from_id_val character varying, catalog_unit__unit_to_id_val character varying)
LANGUAGE plpgsql
AS $function$
BEGIN
RETURN QUERY (
SELECT t.id, t.unit_from_id, t.unit_to_id, t.factor, t.add, unit_from_id.display_name, unit_to_id.display_name
FROM data.unit_conversion t
LEFT JOIN catalog.unit unit_from_id ON unit_from_id.id = t.unit_from_id
LEFT JOIN catalog.unit unit_to_id ON unit_to_id.id = t.unit_to_id
ORDER BY 2
);
END $function$
*/
}
/**
* @function data_unit_conversion_u
* @memberof zzglc
* @description Data unit conversion u
* @param {character_varying} Json
* @returns {integer}
*/
function data_unit_conversion_u() {
/*
CREATE OR REPLACE FUNCTION zzglc.data_unit_conversion_u("Json" character varying)
RETURNS integer
LANGUAGE plpgsql
AS $function$
DECLARE v_id integer;
DECLARE json_data json;
BEGIN
json_data := "Json";
v_id := (json_data->>'id')::integer;
UPDATE data.unit_conversion SET
unit_from_id = (json_data->>'unit_from_id')::integer,
unit_to_id = (json_data->>'unit_to_id')::integer,
factor = (json_data->>'factor')::double precision,
add = (json_data->>'add')::double precision
WHERE id = v_id;
RETURN v_id;
END $function$
*/
}
/**
* @function data_weather_c
* @memberof zzglc
* @description Data weather c
* @param {character_varying} Json
* @returns {integer}
*/
function data_weather_c() {
/*
CREATE OR REPLACE FUNCTION zzglc.data_weather_c("Json" character varying)
RETURNS integer
LANGUAGE plpgsql
AS $function$
DECLARE v_id integer;
DECLARE json_data json;
BEGIN
json_data := "Json";
INSERT INTO data.weather (sampling_log_id, sky_condition_id, ground_condition_id, precipitation_1h, precipitation_24h, temperature_1h_mean, temperature_24h_max, temperature_24h_min, person_id, temperature_24h_mean)
VALUES ((json_data->>'sampling_log_id')::integer, (json_data->>'sky_condition_id')::integer, (json_data->>'ground_condition_id')::integer, (json_data->>'precipitation_1h')::smallint, (json_data->>'precipitation_24h')::smallint, (json_data->>'temperature_1h_mean')::smallint, (json_data->>'temperature_24h_max')::smallint, (json_data->>'temperature_24h_min')::smallint, auth.get_context_person_id(), (json_data->>'temperature_24h_mean')::real)
RETURNING id INTO v_id;
RETURN v_id;
END $function$
*/
}
/**
* @function data_weather_d
* @memberof zzglc
* @description Data weather d
* @param {integer} Key
* @returns {void}
*/
function data_weather_d() {
/*
CREATE OR REPLACE FUNCTION zzglc.data_weather_d("Key" integer)
RETURNS void
LANGUAGE plpgsql
AS $function$
BEGIN
DELETE FROM data.weather WHERE id = "Key";
END;
$function$
*/
}
/**
* @function data_weather_r
* @memberof zzglc
* @description Data weather r
* @param {integer} Key
* @returns {Object} integer idinteger data_sampling_log__sampling_log_idinteger catalog_sky_condition__sky_condition_idinteger catalog_ground_condition__ground_condition_idsmallint precipitation_1hsmallint precipitation_24hsmallint temperature_1h_meansmallint temperature_24h_maxsmallint temperature_24h_mininteger auth_person__person_idreal temperature_24h_meancharacter_varying data_sampling_log__sampling_log_id_valcharacter_varying catalog_sky_condition__sky_condition_id_valcharacter_varying catalog_ground_condition__ground_condition_id_valcharacter_varying auth_person__person_id_val
*/
function data_weather_r() {
/*
CREATE OR REPLACE FUNCTION zzglc.data_weather_r("Key" integer)
RETURNS TABLE(id integer, data_sampling_log__sampling_log_id integer, catalog_sky_condition__sky_condition_id integer, catalog_ground_condition__ground_condition_id integer, precipitation_1h smallint, precipitation_24h smallint, temperature_1h_mean smallint, temperature_24h_max smallint, temperature_24h_min smallint, auth_person__person_id integer, temperature_24h_mean real, data_sampling_log__sampling_log_id_val character varying, catalog_sky_condition__sky_condition_id_val character varying, catalog_ground_condition__ground_condition_id_val character varying, auth_person__person_id_val character varying)
LANGUAGE plpgsql
AS $function$
BEGIN
RETURN QUERY (
SELECT t.id, t.sampling_log_id, t.sky_condition_id, t.ground_condition_id, t.precipitation_1h, t.precipitation_24h, t.temperature_1h_mean, t.temperature_24h_max, t.temperature_24h_min, t.person_id, t.temperature_24h_mean, sampling_log_id.name, sky_condition_id.name, ground_condition_id.name, person_id.email
FROM data.weather t
LEFT JOIN auth.vw_partner vwp ON vwp.user_id = t.person_id AND vwp.partner_user_id = auth.get_context_person_id()
LEFT JOIN data.sampling_log sampling_log_id ON sampling_log_id.id = t.sampling_log_id
LEFT JOIN catalog.sky_condition sky_condition_id ON sky_condition_id.id = t.sky_condition_id
LEFT JOIN catalog.ground_condition ground_condition_id ON ground_condition_id.id = t.ground_condition_id
LEFT JOIN auth.person person_id ON person_id.id = t.person_id
WHERE t.sampling_log_id = "Key"
ORDER BY 2
);
END $function$
*/
}
/**
* @function data_weather_r_overload
* @overload data_weather_r
* @memberof zzglc
* @description Data weather r
* @returns {Object} integer idinteger data_sampling_log__sampling_log_idinteger catalog_sky_condition__sky_condition_idinteger catalog_ground_condition__ground_condition_idsmallint precipitation_1hsmallint precipitation_24hsmallint temperature_1h_meansmallint temperature_24h_maxsmallint temperature_24h_mininteger auth_person__person_idreal temperature_24h_meancharacter_varying data_sampling_log__sampling_log_id_valcharacter_varying catalog_sky_condition__sky_condition_id_valcharacter_varying catalog_ground_condition__ground_condition_id_valcharacter_varying auth_person__person_id_val
*/
function data_weather_r_overload() {
/*
CREATE OR REPLACE FUNCTION zzglc.data_weather_r()
RETURNS TABLE(id integer, data_sampling_log__sampling_log_id integer, catalog_sky_condition__sky_condition_id integer, catalog_ground_condition__ground_condition_id integer, precipitation_1h smallint, precipitation_24h smallint, temperature_1h_mean smallint, temperature_24h_max smallint, temperature_24h_min smallint, auth_person__person_id integer, temperature_24h_mean real, data_sampling_log__sampling_log_id_val character varying, catalog_sky_condition__sky_condition_id_val character varying, catalog_ground_condition__ground_condition_id_val character varying, auth_person__person_id_val character varying)
LANGUAGE plpgsql
AS $function$
BEGIN
RETURN QUERY (
SELECT t.id, t.sampling_log_id, t.sky_condition_id, t.ground_condition_id, t.precipitation_1h, t.precipitation_24h, t.temperature_1h_mean, t.temperature_24h_max, t.temperature_24h_min, t.person_id, t.temperature_24h_mean, sampling_log_id.name, sky_condition_id.name, ground_condition_id.name, person_id.email
FROM data.weather t
LEFT JOIN auth.vw_partner vwp ON vwp.user_id = t.person_id AND vwp.partner_user_id = auth.get_context_person_id()
LEFT JOIN data.sampling_log sampling_log_id ON sampling_log_id.id = t.sampling_log_id
LEFT JOIN catalog.sky_condition sky_condition_id ON sky_condition_id.id = t.sky_condition_id
LEFT JOIN catalog.ground_condition ground_condition_id ON ground_condition_id.id = t.ground_condition_id
LEFT JOIN auth.person person_id ON person_id.id = t.person_id
WHERE vwp.user_id = auth.get_context_person_id() OR auth.get_context_is_admin()
ORDER BY 2
);
END $function$
*/
}
/**
* @function data_weather_s_r
* @memberof zzglc
* @description Data weather s r
* @param {integer} Key
* @returns {Object} integer idinteger data_sampling_log__sampling_log_idinteger catalog_sky_condition__sky_condition_idinteger catalog_ground_condition__ground_condition_idsmallint precipitation_1hsmallint precipitation_24hsmallint temperature_1h_meansmallint temperature_24h_maxsmallint temperature_24h_mininteger auth_person__person_idreal temperature_24h_meancharacter_varying data_sampling_log__sampling_log_id_valcharacter_varying catalog_sky_condition__sky_condition_id_valcharacter_varying catalog_ground_condition__ground_condition_id_valcharacter_varying auth_person__person_id_val
*/
function data_weather_s_r() {
/*
CREATE OR REPLACE FUNCTION zzglc.data_weather_s_r("Key" integer)
RETURNS TABLE(id integer, data_sampling_log__sampling_log_id integer, catalog_sky_condition__sky_condition_id integer, catalog_ground_condition__ground_condition_id integer, precipitation_1h smallint, precipitation_24h smallint, temperature_1h_mean smallint, temperature_24h_max smallint, temperature_24h_min smallint, auth_person__person_id integer, temperature_24h_mean real, data_sampling_log__sampling_log_id_val character varying, catalog_sky_condition__sky_condition_id_val character varying, catalog_ground_condition__ground_condition_id_val character varying, auth_person__person_id_val character varying)
LANGUAGE plpgsql
AS $function$
BEGIN
RETURN QUERY (
SELECT t.id, t.sampling_log_id, t.sky_condition_id, t.ground_condition_id, t.precipitation_1h, t.precipitation_24h, t.temperature_1h_mean, t.temperature_24h_max, t.temperature_24h_min, t.person_id, t.temperature_24h_mean, sampling_log_id.name, sky_condition_id.name, ground_condition_id.name, person_id.email
FROM data.weather t
LEFT JOIN data.sampling_log sampling_log_id ON sampling_log_id.id = t.sampling_log_id
LEFT JOIN catalog.sky_condition sky_condition_id ON sky_condition_id.id = t.sky_condition_id
LEFT JOIN catalog.ground_condition ground_condition_id ON ground_condition_id.id = t.ground_condition_id
LEFT JOIN auth.person person_id ON person_id.id = t.person_id
WHERE t.id = "Key"
ORDER BY 2
);
END $function$
*/
}
/**
* @function data_weather_u
* @memberof zzglc
* @description Data weather u
* @param {character_varying} Json
* @returns {integer}
*/
function data_weather_u() {
/*
CREATE OR REPLACE FUNCTION zzglc.data_weather_u("Json" character varying)
RETURNS integer
LANGUAGE plpgsql
AS $function$
DECLARE v_id integer;
DECLARE json_data json;
BEGIN
json_data := "Json";
v_id := (json_data->>'id')::integer;
UPDATE data.weather SET
sampling_log_id = (json_data->>'sampling_log_id')::integer,
sky_condition_id = (json_data->>'sky_condition_id')::integer,
ground_condition_id = (json_data->>'ground_condition_id')::integer,
precipitation_1h = (json_data->>'precipitation_1h')::smallint,
precipitation_24h = (json_data->>'precipitation_24h')::smallint,
temperature_1h_mean = (json_data->>'temperature_1h_mean')::smallint,
temperature_24h_max = (json_data->>'temperature_24h_max')::smallint,
temperature_24h_min = (json_data->>'temperature_24h_min')::smallint,
person_id = (json_data->>'person_id')::integer,
temperature_24h_mean = (json_data->>'temperature_24h_mean')::real
WHERE id = v_id;
RETURN v_id;
END $function$
*/
}
/**
* @function general_ai_model_c
* @memberof zzglc
* @description General ai model c
* @param {character_varying} Json
* @returns {integer}
*/
function general_ai_model_c() {
/*
CREATE OR REPLACE FUNCTION zzglc.general_ai_model_c("Json" character varying)
RETURNS integer
LANGUAGE plpgsql
AS $function$
DECLARE v_id integer;
DECLARE json_data json;
BEGIN
json_data := "Json";
INSERT INTO general.ai_model (name, url, username, password, method_id, body, answer, active)
VALUES ((json_data->>'name')::character varying, (json_data->>'url')::character varying, (json_data->>'username')::character varying, (json_data->>'password')::character varying, (json_data->>'method_id')::integer, (json_data->>'body')::json, (json_data->>'answer')::character varying, (json_data->>'active')::boolean)
RETURNING id INTO v_id;
RETURN v_id;
END $function$
*/
}
/**
* @function general_ai_model_d
* @memberof zzglc
* @description General ai model d
* @param {integer} Key
* @returns {void}
*/
function general_ai_model_d() {
/*
CREATE OR REPLACE FUNCTION zzglc.general_ai_model_d("Key" integer)
RETURNS void
LANGUAGE plpgsql
AS $function$
BEGIN
DELETE FROM general.ai_model WHERE id = "Key";
END;
$function$
*/
}
/**
* @function general_ai_model_r
* @memberof zzglc
* @description General ai model r
* @returns {Object} integer idcharacter_varying namecharacter_varying urlcharacter_varying usernamecharacter_varying passwordinteger general_method__method_idjson bodycharacter_varying answerboolean activecharacter_varying general_method__method_id_val
*/
function general_ai_model_r() {
/*
CREATE OR REPLACE FUNCTION zzglc.general_ai_model_r()
RETURNS TABLE(id integer, name character varying, url character varying, username character varying, password character varying, general_method__method_id integer, body json, answer character varying, active boolean, general_method__method_id_val character varying)
LANGUAGE plpgsql
AS $function$
BEGIN
RETURN QUERY (
SELECT t.id, t.name, t.url, t.username, t.password, t.method_id, t.body, t.answer, t.active, method_id.name
FROM general.ai_model t
LEFT JOIN general.method method_id ON method_id.id = t.method_id
ORDER BY 2
);
END $function$
*/
}
/**
* @function general_ai_model_u
* @memberof zzglc
* @description General ai model u
* @param {character_varying} Json
* @returns {void}
*/
function general_ai_model_u() {
/*
CREATE OR REPLACE FUNCTION zzglc.general_ai_model_u("Json" character varying)
RETURNS void
LANGUAGE plpgsql
AS $function$
DECLARE json_data json;
BEGIN
json_data := "Json";
UPDATE general.ai_model SET
name = (json_data->>'name')::character varying,
url = (json_data->>'url')::character varying,
username = (json_data->>'username')::character varying,
password = (json_data->>'password')::character varying,
method_id = (json_data->>'method_id')::integer,
body = (json_data->>'body')::json,
answer = (json_data->>'answer')::character varying,
active = (json_data->>'active')::boolean
WHERE id = (json_data->>'id')::integer;
END $function$
*/
}
/**
* @function general_boundary_c
* @memberof zzglc
* @description General boundary c
* @param {character_varying} Json
* @returns {void}
*/
function general_boundary_c() {
/*
CREATE OR REPLACE FUNCTION zzglc.general_boundary_c("Json" character varying)
RETURNS void
LANGUAGE plpgsql
AS $function$
BEGIN
INSERT INTO general.boundary (
osm_id,
admin_level,
name,
local_name,
geom
)
SELECT
U.osm_id,
U.admin_level,
U.name,
U.local_name,
U.geom
FROM
json_to_record("Json"::json) U (
osm_id integer,
admin_level integer,
name character varying,
local_name character varying,
geom geometry
)
;
END $function$
*/
}
/**
* @function general_boundary_d
* @memberof zzglc
* @description General boundary d
* @param {integer} Key
* @returns {void}
*/
function general_boundary_d() {
/*
CREATE OR REPLACE FUNCTION zzglc.general_boundary_d("Key" integer)
RETURNS void
LANGUAGE plpgsql
AS $function$
BEGIN
DELETE FROM general.boundary
WHERE id = "Key";
END $function$
*/
}
/**
* @function general_boundary_r
* @memberof zzglc
* @description General boundary r
* @returns {Object}
* @property {integer} id
* @property {integer} osm_id
* @property {integer} admin_level
* @property {character_varying} name
* @property {character_varying} local_name
*/
function general_boundary_r() {
/*
CREATE OR REPLACE FUNCTION zzglc.general_boundary_r()
RETURNS TABLE(id integer, osm_id integer, admin_level integer, name character varying, local_name character varying)
LANGUAGE plpgsql
AS $function$
BEGIN
RETURN QUERY
SELECT
t.id, t.osm_id, t.admin_level, t.name, t.local_name
FROM general.boundary t
;
END $function$
*/
}
/**
* @function general_boundary_u
* @memberof zzglc
* @description General boundary u
* @param {character_varying} Json
* @returns {void}
*/
function general_boundary_u() {
/*
CREATE OR REPLACE FUNCTION zzglc.general_boundary_u("Json" character varying)
RETURNS void
LANGUAGE plpgsql
AS $function$
DECLARE v_row_count INTEGER;
BEGIN
UPDATE general.boundary t
SET osm_id = U.osm_id,
admin_level = U.admin_level,
name = U.name,
local_name = U.local_name,
geom = U.geom
FROM json_to_record("Json"::json) AS U (
id integer,
osm_id integer,
admin_level integer,
name character varying(255),
local_name character varying(255),
geom geometry(MultiPolygon,3035)
)
WHERE U.id = t.id
;
END $function$
*/
}
/**
* @function general_color_c
* @memberof zzglc
* @description General color c
* @param {character_varying} Json
* @returns {integer}
*/
function general_color_c() {
/*
CREATE OR REPLACE FUNCTION zzglc.general_color_c("Json" character varying)
RETURNS integer
LANGUAGE plpgsql
AS $function$
DECLARE v_id integer;
DECLARE json_data json;
BEGIN
json_data := "Json";
INSERT INTO general.color (name, code, order_no)
VALUES ((json_data->>'name')::character varying, (json_data->>'code')::character varying, (json_data->>'order_no')::integer)
RETURNING id INTO v_id;
RETURN v_id;
END $function$
*/
}
/**
* @function general_color_d
* @memberof zzglc
* @description General color d
* @param {integer} Key
* @returns {void}
*/
function general_color_d() {
/*
CREATE OR REPLACE FUNCTION zzglc.general_color_d("Key" integer)
RETURNS void
LANGUAGE plpgsql
AS $function$
BEGIN
DELETE FROM general.color WHERE id = "Key";
END;
$function$
*/
}
/**
* @function general_color_r
* @memberof zzglc
* @description General color r
* @returns {Object} integer idcharacter_varying namecharacter_varying codeinteger order_no
*/
function general_color_r() {
/*
CREATE OR REPLACE FUNCTION zzglc.general_color_r()
RETURNS TABLE(id integer, name character varying, code character varying, order_no integer)
LANGUAGE plpgsql
AS $function$
BEGIN
RETURN QUERY (
SELECT t.id, t.name, t.code, t.order_no
FROM general.color t
ORDER BY 2
);
END $function$
*/
}
/**
* @function general_color_u
* @memberof zzglc
* @description General color u
* @param {character_varying} Json
* @returns {integer}
*/
function general_color_u() {
/*
CREATE OR REPLACE FUNCTION zzglc.general_color_u("Json" character varying)
RETURNS integer
LANGUAGE plpgsql
AS $function$
DECLARE v_id integer;
DECLARE json_data json;
BEGIN
json_data := "Json";
v_id := (json_data->>'id')::integer;
UPDATE general.color SET
name = (json_data->>'name')::character varying,
code = (json_data->>'code')::character varying,
order_no = (json_data->>'order_no')::integer
WHERE id = v_id;
RETURN v_id;
END $function$
*/
}
/**
* @function general_country_c
* @memberof zzglc
* @description General country c
* @param {character_varying} Json
* @returns {integer}
*/
function general_country_c() {
/*
CREATE OR REPLACE FUNCTION zzglc.general_country_c("Json" character varying)
RETURNS integer
LANGUAGE plpgsql
AS $function$
DECLARE v_id integer;
DECLARE json_data json;
BEGIN
json_data := "Json";
INSERT INTO general.country (name, code, region_id, sub_region_id, osm_id, lucas_code)
VALUES ((json_data->>'name')::character varying, (json_data->>'code')::character, (json_data->>'region_id')::integer, (json_data->>'sub_region_id')::integer, (json_data->>'osm_id')::integer, (json_data->>'lucas_code')::character)
RETURNING id INTO v_id;
RETURN v_id;
END $function$
*/
}
/**
* @function general_country_d
* @memberof zzglc
* @description General country d
* @param {integer} Key
* @returns {void}
*/
function general_country_d() {
/*
CREATE OR REPLACE FUNCTION zzglc.general_country_d("Key" integer)
RETURNS void
LANGUAGE plpgsql
AS $function$
BEGIN
DELETE FROM general.country WHERE id = "Key";
END;
$function$
*/
}
/**
* @function general_country_r
* @memberof zzglc
* @description General country r
* @returns {Object} integer idcharacter_varying namecharacter codeinteger general_region__region_idinteger general_sub_region__sub_region_idinteger osm_idcharacter lucas_codecharacter_varying general_region__region_id_valcharacter_varying general_sub_region__sub_region_id_val
*/
function general_country_r() {
/*
CREATE OR REPLACE FUNCTION zzglc.general_country_r()
RETURNS TABLE(id integer, name character varying, code character, general_region__region_id integer, general_sub_region__sub_region_id integer, osm_id integer, lucas_code character, general_region__region_id_val character varying, general_sub_region__sub_region_id_val character varying)
LANGUAGE plpgsql
AS $function$
BEGIN
RETURN QUERY (
SELECT t.id, t.name, t.code, t.region_id, t.sub_region_id, t.osm_id, t.lucas_code, region_id.name, sub_region_id.name
FROM general.country t
LEFT JOIN general.region region_id ON region_id.id = t.region_id
LEFT JOIN general.sub_region sub_region_id ON sub_region_id.id = t.sub_region_id
ORDER BY 2
);
END $function$
*/
}
/**
* @function general_country_u
* @memberof zzglc
* @description General country u
* @param {character_varying} Json
* @returns {void}
*/
function general_country_u() {
/*
CREATE OR REPLACE FUNCTION zzglc.general_country_u("Json" character varying)
RETURNS void
LANGUAGE plpgsql
AS $function$
DECLARE json_data json;
BEGIN
json_data := "Json";
UPDATE general.country SET
name = (json_data->>'name')::character varying,
code = (json_data->>'code')::character,
region_id = (json_data->>'region_id')::integer,
sub_region_id = (json_data->>'sub_region_id')::integer,
osm_id = (json_data->>'osm_id')::integer,
lucas_code = (json_data->>'lucas_code')::character
WHERE id = (json_data->>'id')::integer;
END $function$
*/
}
/**
* @function general_email_provider_c
* @memberof zzglc
* @description General email provider c
* @param {character_varying} Json
* @returns {integer}
*/
function general_email_provider_c() {
/*
CREATE OR REPLACE FUNCTION zzglc.general_email_provider_c("Json" character varying)
RETURNS integer
LANGUAGE plpgsql
AS $function$
DECLARE v_id integer;
DECLARE json_data json;
BEGIN
json_data := "Json";
INSERT INTO general.email_provider (name, smtp, port, username, password, user_id, sender_name, sender_from, "default", email_ssl_id)
VALUES ((json_data->>'name')::character varying,
(json_data->>'smtp')::character varying,
(json_data->>'port')::integer,
(json_data->>'username')::character varying,
meta.encrypt_varchar((json_data->>'password')::character varying),
auth.get_context_person_id(),
(json_data->>'sender_name')::character varying,
(json_data->>'sender_from')::character varying,
(json_data->>'default')::boolean,
email_ssl_id = (json_data->>'email_ssl_id')::integer)
RETURNING id INTO v_id;
RETURN v_id;
END $function$
*/
}
/**
* @function general_email_provider_d
* @memberof zzglc
* @description General email provider d
* @param {integer} Key
* @returns {void}
*/
function general_email_provider_d() {
/*
CREATE OR REPLACE FUNCTION zzglc.general_email_provider_d("Key" integer)
RETURNS void
LANGUAGE plpgsql
AS $function$
BEGIN
DELETE FROM general.email_provider WHERE id = "Key";
END;
$function$
*/
}
/**
* @function general_email_provider_r
* @memberof zzglc
* @description General email provider r
* @returns {Object} integer idcharacter_varying namecharacter_varying smtpinteger portinteger general_email_ssl__email_ssl_idcharacter_varying sender_namecharacter_varying sender_fromcharacter_varying usernamecharacter_varying passwordboolean defaultcharacter_varying general_email_ssl__email_ssl_id_val
*/
function general_email_provider_r() {
/*
CREATE OR REPLACE FUNCTION zzglc.general_email_provider_r()
RETURNS TABLE(id integer, name character varying, smtp character varying, port integer, general_email_ssl__email_ssl_id integer, sender_name character varying, sender_from character varying, username character varying, password character varying, "default" boolean, general_email_ssl__email_ssl_id_val character varying)
LANGUAGE plpgsql
AS $function$
BEGIN
RETURN QUERY (SELECT t.id, t.name, t.smtp, t.port, t.email_ssl_id, t.sender_name, t.sender_from, t.username, meta.decrypt_varchar(t.password), t.default, email_ssl_id.name
FROM general.email_provider t
LEFT JOIN general.email_ssl email_ssl_id ON t.email_ssl_id = email_ssl_id.id
WHERE t.user_id = auth.get_context_person_id()
ORDER BY t.name);
END $function$
*/
}
/**
* @function general_email_provider_u
* @memberof zzglc
* @description General email provider u
* @param {character_varying} Json
* @returns {void}
*/
function general_email_provider_u() {
/*
CREATE OR REPLACE FUNCTION zzglc.general_email_provider_u("Json" character varying)
RETURNS void
LANGUAGE plpgsql
AS $function$
DECLARE json_data json;
BEGIN
json_data := "Json";
UPDATE general.email_provider SET
name = (json_data->>'name')::character varying,
smtp = (json_data->>'smtp')::character varying,
port = (json_data->>'port')::integer,
username = (json_data->>'username')::character varying,
password = meta.encrypt_varchar((json_data->>'password')::character varying),
sender_name = (json_data->>'sender_name')::character varying,
sender_from = (json_data->>'sender_from')::character varying,
"default" = (json_data->>'default')::boolean,
email_ssl_id = (json_data->>'email_ssl_id')::integer
WHERE id = (json_data->>'id')::integer;
END $function$
*/
}
/**
* @function general_email_ssl_c
* @memberof zzglc
* @description General email ssl c
* @param {character_varying} Json
* @returns {integer}
*/
function general_email_ssl_c() {
/*
CREATE OR REPLACE FUNCTION zzglc.general_email_ssl_c("Json" character varying)
RETURNS integer
LANGUAGE plpgsql
AS $function$
DECLARE v_id integer;
DECLARE json_data json;
BEGIN
json_data := "Json";
INSERT INTO general.email_ssl (name)
VALUES ((json_data->>'name')::character varying)
RETURNING id INTO v_id;
RETURN v_id;
END $function$
*/
}
/**
* @function general_email_ssl_d
* @memberof zzglc
* @description General email ssl d
* @param {integer} Key
* @returns {void}
*/
function general_email_ssl_d() {
/*
CREATE OR REPLACE FUNCTION zzglc.general_email_ssl_d("Key" integer)
RETURNS void
LANGUAGE plpgsql
AS $function$
BEGIN
DELETE FROM general.email_ssl WHERE id = "Key";
END;
$function$
*/
}
/**
* @function general_email_ssl_r
* @memberof zzglc
* @description General email ssl r
* @returns {Object} integer idcharacter_varying name
*/
function general_email_ssl_r() {
/*
CREATE OR REPLACE FUNCTION zzglc.general_email_ssl_r()
RETURNS TABLE(id integer, name character varying)
LANGUAGE plpgsql
AS $function$
BEGIN
RETURN QUERY (
SELECT t.id, t.name
FROM general.email_ssl t
ORDER BY 2
);
END $function$
*/
}
/**
* @function general_email_ssl_u
* @memberof zzglc
* @description General email ssl u
* @param {character_varying} Json
* @returns {integer}
*/
function general_email_ssl_u() {
/*
CREATE OR REPLACE FUNCTION zzglc.general_email_ssl_u("Json" character varying)
RETURNS integer
LANGUAGE plpgsql
AS $function$
DECLARE v_id integer;
DECLARE json_data json;
BEGIN
json_data := "Json";
v_id := (json_data->>'id')::integer;
UPDATE general.email_ssl SET
name = (json_data->>'name')::character varying
WHERE id = v_id;
RETURN v_id;
END $function$
*/
}
/**
* @function general_file_c
* @memberof zzglc
* @description General file c
* @param {character_varying} Json
* @returns {integer}
*/
function general_file_c() {
/*
CREATE OR REPLACE FUNCTION zzglc.general_file_c("Json" character varying)
RETURNS integer
LANGUAGE plpgsql
AS $function$
DECLARE v_id integer;
DECLARE json_data json;
BEGIN
json_data := "Json";
INSERT INTO general.file (name, size, zipped_size, original_name, file_id, public, time_created)
VALUES ((json_data->>'name')::character varying, (json_data->>'size')::integer, (json_data->>'zipped_size')::integer, (json_data->>'original_name')::character varying, (json_data->>'file_id')::character varying, (json_data->>'public')::boolean, (json_data->>'time_created')::timestamp with time zone)
RETURNING id INTO v_id;
RETURN v_id;
END $function$
*/
}
/**
* @function general_file_d
* @memberof zzglc
* @description General file d
* @param {integer} Key
* @returns {void}
*/
function general_file_d() {
/*
CREATE OR REPLACE FUNCTION zzglc.general_file_d("Key" integer)
RETURNS void
LANGUAGE plpgsql
AS $function$
BEGIN
DELETE FROM general.file WHERE id = "Key";
END;
$function$
*/
}
/**
* @function general_file_r
* @memberof zzglc
* @description General file r
* @returns {Object} integer idcharacter_varying nameinteger sizeinteger zipped_sizecharacter_varying original_namecharacter_varying file_idboolean publictimestamp_with_time_zone time_created
*/
function general_file_r() {
/*
CREATE OR REPLACE FUNCTION zzglc.general_file_r()
RETURNS TABLE(id integer, name character varying, size integer, zipped_size integer, original_name character varying, file_id character varying, public boolean, time_created timestamp with time zone)
LANGUAGE plpgsql
AS $function$
BEGIN
RETURN QUERY (
SELECT t.id, t.name, t.size, t.zipped_size, t.original_name, t.file_id, t.public, t.time_created
FROM general.file t
ORDER BY 2
);
END $function$
*/
}
/**
* @function general_file_u
* @memberof zzglc
* @description General file u
* @param {character_varying} Json
* @returns {integer}
*/
function general_file_u() {
/*
CREATE OR REPLACE FUNCTION zzglc.general_file_u("Json" character varying)
RETURNS integer
LANGUAGE plpgsql
AS $function$
DECLARE v_id integer;
DECLARE json_data json;
BEGIN
json_data := "Json";
v_id := (json_data->>'id')::integer;
UPDATE general.file SET
name = (json_data->>'name')::character varying,
size = (json_data->>'size')::integer,
zipped_size = (json_data->>'zipped_size')::integer,
original_name = (json_data->>'original_name')::character varying,
file_id = (json_data->>'file_id')::character varying,
public = (json_data->>'public')::boolean,
time_created = (json_data->>'time_created')::timestamp with time zone
WHERE id = v_id;
RETURN v_id;
END $function$
*/
}
/**
* @function general_forum_topic_c
* @memberof zzglc
* @description General forum topic c
* @param {character_varying} Json
* @returns {integer}
*/
function general_forum_topic_c() {
/*
CREATE OR REPLACE FUNCTION zzglc.general_forum_topic_c("Json" character varying)
RETURNS integer
LANGUAGE plpgsql
AS $function$
DECLARE v_id integer;
DECLARE json_data json;
BEGIN
json_data := "Json";
INSERT INTO general.forum_topic (name)
VALUES ((json_data->>'name')::character varying)
RETURNING id INTO v_id;
RETURN v_id;
END $function$
*/
}
/**
* @function general_forum_topic_d
* @memberof zzglc
* @description General forum topic d
* @param {integer} Key
* @returns {void}
*/
function general_forum_topic_d() {
/*
CREATE OR REPLACE FUNCTION zzglc.general_forum_topic_d("Key" integer)
RETURNS void
LANGUAGE plpgsql
AS $function$
BEGIN
DELETE FROM general.forum_topic WHERE id = "Key";
END;
$function$
*/
}
/**
* @function general_forum_topic_r
* @memberof zzglc
* @description General forum topic r
* @returns {Object} integer idcharacter_varying name
*/
function general_forum_topic_r() {
/*
CREATE OR REPLACE FUNCTION zzglc.general_forum_topic_r()
RETURNS TABLE(id integer, name character varying)
LANGUAGE plpgsql
AS $function$
BEGIN
RETURN QUERY (
SELECT t.id, t.name
FROM general.forum_topic t
ORDER BY 2
);
END $function$
*/
}
/**
* @function general_forum_topic_u
* @memberof zzglc
* @description General forum topic u
* @param {character_varying} Json
* @returns {void}
*/
function general_forum_topic_u() {
/*
CREATE OR REPLACE FUNCTION zzglc.general_forum_topic_u("Json" character varying)
RETURNS void
LANGUAGE plpgsql
AS $function$
DECLARE json_data json;
BEGIN
json_data := "Json";
UPDATE general.forum_topic SET
name = (json_data->>'name')::character varying
WHERE id = (json_data->>'id')::integer;
END $function$
*/
}
/**
* @function general_message_c
* @memberof zzglc
* @description General message c
* @param {character_varying} Json
* @returns {integer}
*/
function general_message_c() {
/*
CREATE OR REPLACE FUNCTION zzglc.general_message_c("Json" character varying)
RETURNS integer
LANGUAGE plpgsql
AS $function$
DECLARE v_id integer;
DECLARE json_data json;
BEGIN
json_data := "Json";
INSERT INTO general.message (person_id, response, time_modified, prompt)
VALUES ((json_data->>'person_id')::integer, (json_data->>'response')::text, (json_data->>'time_modified')::timestamp without time zone, (json_data->>'prompt')::text)
RETURNING id INTO v_id;
RETURN v_id;
END $function$
*/
}
/**
* @function general_message_d
* @memberof zzglc
* @description General message d
* @param {integer} Key
* @returns {void}
*/
function general_message_d() {
/*
CREATE OR REPLACE FUNCTION zzglc.general_message_d("Key" integer)
RETURNS void
LANGUAGE plpgsql
AS $function$
BEGIN
DELETE FROM general.message WHERE id = "Key";
END;
$function$
*/
}
/**
* @function general_message_r
* @memberof zzglc
* @description General message r
* @returns {Object} integer idinteger auth_person__person_idtext responsetimestamp_without_time_zone time_modifiedtext promptcharacter_varying auth_person__person_id_val
*/
function general_message_r() {
/*
CREATE OR REPLACE FUNCTION zzglc.general_message_r()
RETURNS TABLE(id integer, auth_person__person_id integer, response text, time_modified timestamp without time zone, prompt text, auth_person__person_id_val character varying)
LANGUAGE plpgsql
AS $function$
BEGIN
RETURN QUERY (
SELECT t.id, t.person_id, t.response, t.time_modified, t.prompt, person_id.name
FROM general.message t
LEFT JOIN auth.person person_id ON person_id.id = t.person_id
ORDER BY 2
);
END $function$
*/
}
/**
* @function general_message_u
* @memberof zzglc
* @description General message u
* @param {character_varying} Json
* @returns {void}
*/
function general_message_u() {
/*
CREATE OR REPLACE FUNCTION zzglc.general_message_u("Json" character varying)
RETURNS void
LANGUAGE plpgsql
AS $function$
DECLARE json_data json;
BEGIN
json_data := "Json";
UPDATE general.message SET
person_id = (json_data->>'person_id')::integer,
response = (json_data->>'response')::text,
time_modified = (json_data->>'time_modified')::timestamp without time zone,
prompt = (json_data->>'prompt')::text
WHERE id = (json_data->>'id')::integer;
END $function$
*/
}
/**
* @function general_nuts_c
* @memberof zzglc
* @description General nuts c
* @param {character_varying} Json
* @returns {void}
*/
function general_nuts_c() {
/*
CREATE OR REPLACE FUNCTION zzglc.general_nuts_c("Json" character varying)
RETURNS void
LANGUAGE plpgsql
AS $function$
BEGIN
INSERT INTO general.nuts (
nuts_id,
levl_code,
cntr_code,
name_latn,
nuts_name,
mount_type,
urbn_type,
coast_type,
fid,
geom
)
SELECT
U.nuts_id,
U.levl_code,
U.cntr_code,
U.name_latn,
U.nuts_name,
U.mount_type,
U.urbn_type,
U.coast_type,
U.fid,
U.geom
FROM
json_to_record("Json"::json) U (
nuts_id character varying,
levl_code integer,
cntr_code character(2),
name_latn character varying(255),
nuts_name character varying(255),
mount_type integer,
urbn_type integer,
coast_type integer,
fid character varying,
geom geometry
)
;
END $function$
*/
}
/**
* @function general_nuts_d
* @memberof zzglc
* @description General nuts d
* @param {integer} Key
* @returns {void}
*/
function general_nuts_d() {
/*
CREATE OR REPLACE FUNCTION zzglc.general_nuts_d("Key" integer)
RETURNS void
LANGUAGE plpgsql
AS $function$
BEGIN
DELETE FROM general.nuts
WHERE id = "Key";
END $function$
*/
}
/**
* @function general_nuts_r
* @memberof zzglc
* @description General nuts r
* @returns {Object}
* @property {integer} id
* @property {character_varying} nuts_id
* @property {integer} levl_code
* @property {character} cntr_code
* @property {character_varying} name_latn
* @property {character_varying} nuts_name
* @property {integer} mount_type
* @property {integer} urbn_type
* @property {integer} coast_type
* @property {character_varying} fid
*/
function general_nuts_r() {
/*
CREATE OR REPLACE FUNCTION zzglc.general_nuts_r()
RETURNS TABLE(id integer, nuts_id character varying, levl_code integer, cntr_code character, name_latn character varying, nuts_name character varying, mount_type integer, urbn_type integer, coast_type integer, fid character varying)
LANGUAGE plpgsql
AS $function$
BEGIN
RETURN QUERY
SELECT
t.id, t.nuts_id, t.levl_code, t.cntr_code, t.name_latn, t.nuts_name, t.mount_type, t.urbn_type, t.coast_type, t.fid
FROM general.nuts t
;
END $function$
*/
}
/**
* @function general_nuts_u
* @memberof zzglc
* @description General nuts u
* @param {character_varying} Json
* @returns {void}
*/
function general_nuts_u() {
/*
CREATE OR REPLACE FUNCTION zzglc.general_nuts_u("Json" character varying)
RETURNS void
LANGUAGE plpgsql
AS $function$
DECLARE v_row_count INTEGER;
BEGIN
UPDATE general.nuts t
SET nuts_id = U.nuts_id,
levl_code = U.levl_code,
cntr_code = U.cntr_code,
name_latn = U.name_latn,
nuts_name = U.nuts_name,
mount_type = U.mount_type,
urbn_type = U.urbn_type,
coast_type = U.coast_type,
fid = U.fid,
geom = U.geom
FROM json_to_record("Json"::json) AS U (
id integer,
nuts_id character varying,
levl_code integer,
cntr_code character(2),
name_latn character varying(255),
nuts_name character varying(255),
mount_type integer,
urbn_type integer,
coast_type integer,
fid character varying,
geom geometry
)
WHERE U.id = t.id
;
END $function$
*/
}
/**
* @function general_partner_c
* @memberof zzglc
* @description General partner c
* @param {character_varying} Json
* @returns {void}
*/
function general_partner_c() {
/*
CREATE OR REPLACE FUNCTION zzglc.general_partner_c("Json" character varying)
RETURNS void
LANGUAGE plpgsql
AS $function$
BEGIN
INSERT INTO general.partner (
short_name,
name,
user_modified
)
SELECT
U.short_name,
U.name
FROM
json_to_record("Json"::json) U (
short_name character varying,
name character varying
)
;
END $function$
*/
}
/**
* @function general_partner_d
* @memberof zzglc
* @description General partner d
* @param {integer} Key
* @returns {void}
*/
function general_partner_d() {
/*
CREATE OR REPLACE FUNCTION zzglc.general_partner_d("Key" integer)
RETURNS void
LANGUAGE plpgsql
AS $function$
BEGIN
DELETE FROM general.partner
WHERE id = "Key";
END $function$
*/
}
/**
* @function general_partner_r
* @memberof zzglc
* @description General partner r
* @returns {Object}
* @property {integer} id
* @property {character_varying} short_name
* @property {character_varying} name
* @property {timestamp_without_time_zone} time_modified
* @property {integer} user_modified
* @property {character_varying} user_modified_val
*/
function general_partner_r() {
/*
CREATE OR REPLACE FUNCTION zzglc.general_partner_r()
RETURNS TABLE(id integer, short_name character varying, name character varying, time_modified timestamp without time zone, auth_person__user_modified_id integer, auth_person__user_modified_val character varying)
LANGUAGE plpgsql
AS $function$
BEGIN
RETURN QUERY
SELECT
t.id, t.short_name, t.name, t.time_modified, t.user_modified_id
, user_modified_t.name::VARCHAR AS user_modified_val
FROM general.partner t
LEFT JOIN auth.person user_modified_t ON user_modified_t.id = t.user_modified_id
ORDER BY t.name
;
END $function$
*/
}
/**
* @function general_partner_u
* @memberof zzglc
* @description General partner u
* @param {character_varying} Json
* @returns {void}
*/
function general_partner_u() {
/*
CREATE OR REPLACE FUNCTION zzglc.general_partner_u("Json" character varying)
RETURNS void
LANGUAGE plpgsql
AS $function$
DECLARE v_row_count INTEGER;
BEGIN
UPDATE general.partner t
SET short_name = U.short_name,
name = U.name
FROM json_to_record("Json"::json) AS U (
id integer,
short_name character varying(64),
name character varying(256),
time_modified timestamp without time zone
)
WHERE U.id = t.id
AND t.time_modified = U.time_modified;
GET DIAGNOSTICS v_row_count = ROW_COUNT;
IF v_row_count = 0 THEN
SELECT meta.raise_error(2);
END IF
;
END $function$
*/
}
/**
* @function general_pdf_template_c
* @memberof zzglc
* @description General pdf template c
* @param {character_varying} Json
* @returns {integer}
*/
function general_pdf_template_c() {
/*
CREATE OR REPLACE FUNCTION zzglc.general_pdf_template_c("Json" character varying)
RETURNS integer
LANGUAGE plpgsql
AS $function$
DECLARE v_id integer;
DECLARE json_data json;
BEGIN
json_data := "Json";
INSERT INTO general.pdf_template (name, api, api_options, state)
VALUES ((json_data->>'name')::character varying, (json_data->>'api')::character varying, (json_data->>'api_options')::json, (json_data->>'state')::json)
RETURNING id INTO v_id;
RETURN v_id;
END $function$
*/
}
/**
* @function general_pdf_template_d
* @memberof zzglc
* @description General pdf template d
* @param {integer} Key
* @returns {void}
*/
function general_pdf_template_d() {
/*
CREATE OR REPLACE FUNCTION zzglc.general_pdf_template_d("Key" integer)
RETURNS void
LANGUAGE plpgsql
AS $function$
BEGIN
DELETE FROM general.pdf_template WHERE id = "Key";
END;
$function$
*/
}
/**
* @function general_pdf_template_r
* @memberof zzglc
* @description General pdf template r
* @returns {Object} integer idcharacter_varying namecharacter_varying apijson api_optionsjson state
*/
function general_pdf_template_r() {
/*
CREATE OR REPLACE FUNCTION zzglc.general_pdf_template_r()
RETURNS TABLE(id integer, name character varying, api character varying, api_options json, state json)
LANGUAGE plpgsql
AS $function$
BEGIN
RETURN QUERY (
SELECT t.id, t.name, t.api, t.api_options, t.state
FROM general.pdf_template t
);
END
$function$
*/
}
/**
* @function general_pdf_template_u
* @memberof zzglc
* @description General pdf template u
* @param {character_varying} Json
* @returns {void}
*/
function general_pdf_template_u() {
/*
CREATE OR REPLACE FUNCTION zzglc.general_pdf_template_u("Json" character varying)
RETURNS void
LANGUAGE plpgsql
AS $function$
DECLARE json_data json;
BEGIN
json_data := "Json";
UPDATE general.pdf_template SET
name = (json_data->>'name')::character varying, api = (json_data->>'api')::character varying, api_options = (json_data->>'api_options')::json, state = (json_data->>'state')::json
WHERE id = (json_data->>'id')::integer;
END $function$
*/
}
/**
* @function general_region_c
* @memberof zzglc
* @description General region c
* @param {character_varying} Json
* @returns {void}
*/
function general_region_c() {
/*
CREATE OR REPLACE FUNCTION zzglc.general_region_c("Json" character varying)
RETURNS void
LANGUAGE plpgsql
AS $function$
BEGIN
INSERT INTO general.region (
name
)
SELECT
U.name
FROM
json_to_record("Json"::json) U (
name character varying
)
;
END $function$
*/
}
/**
* @function general_region_d
* @memberof zzglc
* @description General region d
* @param {smallint} Key
* @returns {void}
*/
function general_region_d() {
/*
CREATE OR REPLACE FUNCTION zzglc.general_region_d("Key" smallint)
RETURNS void
LANGUAGE plpgsql
AS $function$
BEGIN
DELETE FROM general.region
WHERE id = "Key";
END $function$
*/
}
/**
* @function general_region_r
* @memberof zzglc
* @description General region r
* @returns {Object}
* @property {smallint} id
* @property {character_varying} name
*/
function general_region_r() {
/*
CREATE OR REPLACE FUNCTION zzglc.general_region_r()
RETURNS TABLE(id smallint, name character varying)
LANGUAGE plpgsql
AS $function$
BEGIN
RETURN QUERY
SELECT
t.id, t.name
FROM general.region t
;
END $function$
*/
}
/**
* @function general_region_u
* @memberof zzglc
* @description General region u
* @param {character_varying} Json
* @returns {void}
*/
function general_region_u() {
/*
CREATE OR REPLACE FUNCTION zzglc.general_region_u("Json" character varying)
RETURNS void
LANGUAGE plpgsql
AS $function$
DECLARE v_row_count INTEGER;
BEGIN
UPDATE general.region t
SET name = U.name
FROM json_to_record("Json"::json) AS U (
id smallint,
name character varying(255)
)
WHERE U.id = t.id
;
END $function$
*/
}
/**
* @function general_room_c
* @memberof zzglc
* @description General room c
* @param {character_varying} Json
* @returns {integer}
*/
function general_room_c() {
/*
CREATE OR REPLACE FUNCTION zzglc.general_room_c("Json" character varying)
RETURNS integer
LANGUAGE plpgsql
AS $function$
DECLARE v_id integer;
DECLARE json_data json;
BEGIN
json_data := "Json";
INSERT INTO general.room (name)
VALUES ((json_data->>'name')::character varying)
RETURNING id INTO v_id;
RETURN v_id;
END $function$
*/
}
/**
* @function general_room_d
* @memberof zzglc
* @description General room d
* @param {integer} Key
* @returns {void}
*/
function general_room_d() {
/*
CREATE OR REPLACE FUNCTION zzglc.general_room_d("Key" integer)
RETURNS void
LANGUAGE plpgsql
AS $function$
BEGIN
DELETE FROM general.room WHERE id = "Key";
END;
$function$
*/
}
/**
* @function general_room_r
* @memberof zzglc
* @description General room r
* @returns {Object} integer idcharacter_varying name
*/
function general_room_r() {
/*
CREATE OR REPLACE FUNCTION zzglc.general_room_r()
RETURNS TABLE(id integer, name character varying)
LANGUAGE plpgsql
AS $function$
BEGIN
RETURN QUERY (
SELECT t.id, t.name
FROM general.room t
ORDER BY 2
);
END $function$
*/
}
/**
* @function general_room_u
* @memberof zzglc
* @description General room u
* @param {character_varying} Json
* @returns {void}
*/
function general_room_u() {
/*
CREATE OR REPLACE FUNCTION zzglc.general_room_u("Json" character varying)
RETURNS void
LANGUAGE plpgsql
AS $function$
DECLARE json_data json;
BEGIN
json_data := "Json";
UPDATE general.room SET
name = (json_data->>'name')::character varying
WHERE id = (json_data->>'id')::integer;
END $function$
*/
}
/**
* @function general_sub_region_c
* @memberof zzglc
* @description General sub region c
* @param {character_varying} Json
* @returns {void}
*/
function general_sub_region_c() {
/*
CREATE OR REPLACE FUNCTION zzglc.general_sub_region_c("Json" character varying)
RETURNS void
LANGUAGE plpgsql
AS $function$
BEGIN
INSERT INTO general.sub_region (
name
)
SELECT
U.name
FROM
json_to_record("Json"::json) U (
name character varying
)
;
END $function$
*/
}
/**
* @function general_sub_region_d
* @memberof zzglc
* @description General sub region d
* @param {smallint} Key
* @returns {void}
*/
function general_sub_region_d() {
/*
CREATE OR REPLACE FUNCTION zzglc.general_sub_region_d("Key" smallint)
RETURNS void
LANGUAGE plpgsql
AS $function$
BEGIN
DELETE FROM general.sub_region
WHERE id = "Key";
END $function$
*/
}
/**
* @function general_sub_region_r
* @memberof zzglc
* @description General sub region r
* @returns {Object}
* @property {smallint} id
* @property {character_varying} name
*/
function general_sub_region_r() {
/*
CREATE OR REPLACE FUNCTION zzglc.general_sub_region_r()
RETURNS TABLE(id smallint, name character varying)
LANGUAGE plpgsql
AS $function$
BEGIN
RETURN QUERY
SELECT
t.id, t.name
FROM general.sub_region t
;
END $function$
*/
}
/**
* @function general_sub_region_u
* @memberof zzglc
* @description General sub region u
* @param {character_varying} Json
* @returns {void}
*/
function general_sub_region_u() {
/*
CREATE OR REPLACE FUNCTION zzglc.general_sub_region_u("Json" character varying)
RETURNS void
LANGUAGE plpgsql
AS $function$
DECLARE v_row_count INTEGER;
BEGIN
UPDATE general.sub_region t
SET name = U.name
FROM json_to_record("Json"::json) AS U (
id smallint,
name character varying(255)
)
WHERE U.id = t.id
;
END $function$
*/
}
/**
* @function log_errors_c
* @memberof zzglc
* @description Log errors c
* @param {character_varying} Json
* @returns {integer}
*/
function log_errors_c() {
/*
CREATE OR REPLACE FUNCTION zzglc.log_errors_c("Json" character varying)
RETURNS integer
LANGUAGE plpgsql
AS $function$
DECLARE v_id integer;
DECLARE json_data json;
BEGIN
json_data := "Json";
INSERT INTO log.errors (message, level, time_stamp, exception, log_event, person_id)
VALUES ((json_data->>'message')::character varying, (json_data->>'level')::character varying, (json_data->>'time_stamp')::timestamp without time zone, (json_data->>'exception')::character varying, (json_data->>'log_event')::character varying, (json_data->>'person_id')::integer)
RETURNING id INTO v_id;
RETURN v_id;
END $function$
*/
}
/**
* @function log_errors_d
* @memberof zzglc
* @description Log errors d
* @param {integer} Key
* @returns {void}
*/
function log_errors_d() {
/*
CREATE OR REPLACE FUNCTION zzglc.log_errors_d("Key" integer)
RETURNS void
LANGUAGE plpgsql
AS $function$
BEGIN
DELETE FROM log.errors WHERE id = "Key";
END;
$function$
*/
}
/**
* @function log_errors_r
* @memberof zzglc
* @description Log errors r
* @returns {Object} integer idcharacter_varying messagecharacter_varying leveltimestamp_without_time_zone time_stampcharacter_varying exceptioncharacter_varying log_eventinteger person_id
*/
function log_errors_r() {
/*
CREATE OR REPLACE FUNCTION zzglc.log_errors_r()
RETURNS TABLE(id integer, message character varying, level character varying, time_stamp timestamp without time zone, exception character varying, log_event character varying, person_id integer)
LANGUAGE plpgsql
AS $function$
BEGIN
RETURN QUERY (
SELECT t.id, t.message, t.level, t.time_stamp, t.exception, t.log_event, t.person_id
FROM log.errors t
ORDER BY t.id DESC
);
END $function$
*/
}
/**
* @function log_errors_u
* @memberof zzglc
* @description Log errors u
* @param {character_varying} Json
* @returns {void}
*/
function log_errors_u() {
/*
CREATE OR REPLACE FUNCTION zzglc.log_errors_u("Json" character varying)
RETURNS void
LANGUAGE plpgsql
AS $function$
DECLARE json_data json;
BEGIN
json_data := "Json";
UPDATE log.errors SET
message = (json_data->>'message')::character varying,
level = (json_data->>'level')::character varying,
time_stamp = (json_data->>'time_stamp')::timestamp without time zone,
exception = (json_data->>'exception')::character varying,
log_event = (json_data->>'log_event')::character varying,
person_id = (json_data->>'person_id')::integer
WHERE id = (json_data->>'id')::integer;
END $function$
*/
}
/**
* @function macrofauna_extraction_method_c
* @memberof zzglc
* @description Macrofauna extraction method c
* @param {character_varying} Json
* @returns {integer}
*/
function macrofauna_extraction_method_c() {
/*
CREATE OR REPLACE FUNCTION zzglc.macrofauna_extraction_method_c("Json" character varying)
RETURNS integer
LANGUAGE plpgsql
AS $function$
DECLARE v_id integer;
DECLARE json_data json;
BEGIN
json_data := "Json";
INSERT INTO macrofauna.extraction_method (name)
VALUES ((json_data->>'name')::character varying)
RETURNING id INTO v_id;
RETURN v_id;
END $function$
*/
}
/**
* @function macrofauna_extraction_method_d
* @memberof zzglc
* @description Macrofauna extraction method d
* @param {integer} Key
* @returns {void}
*/
function macrofauna_extraction_method_d() {
/*
CREATE OR REPLACE FUNCTION zzglc.macrofauna_extraction_method_d("Key" integer)
RETURNS void
LANGUAGE plpgsql
AS $function$
BEGIN
DELETE FROM macrofauna.extraction_method WHERE id = "Key";
END;
$function$
*/
}
/**
* @function macrofauna_extraction_method_r
* @memberof zzglc
* @description Macrofauna extraction method r
* @returns {Object} integer idcharacter_varying name
*/
function macrofauna_extraction_method_r() {
/*
CREATE OR REPLACE FUNCTION zzglc.macrofauna_extraction_method_r()
RETURNS TABLE(id integer, name character varying)
LANGUAGE plpgsql
AS $function$
BEGIN
RETURN QUERY (
SELECT t.id, t.name
FROM macrofauna.extraction_method t
);
END $function$
*/
}
/**
* @function macrofauna_extraction_method_u
* @memberof zzglc
* @description Macrofauna extraction method u
* @param {character_varying} Json
* @returns {void}
*/
function macrofauna_extraction_method_u() {
/*
CREATE OR REPLACE FUNCTION zzglc.macrofauna_extraction_method_u("Json" character varying)
RETURNS void
LANGUAGE plpgsql
AS $function$
DECLARE json_data json;
BEGIN
json_data := "Json";
UPDATE macrofauna.extraction_method SET
name = (json_data->>'name')::character varying
WHERE id = (json_data->>'id')::integer;
END $function$
*/
}
/**
* @function macrofauna_sample_c
* @memberof zzglc
* @description Macrofauna sample c
* @param {character_varying} Json
* @returns {integer}
*/
function macrofauna_sample_c() {
/*
CREATE OR REPLACE FUNCTION zzglc.macrofauna_sample_c("Json" character varying)
RETURNS integer
LANGUAGE plpgsql
AS $function$
DECLARE v_id integer;
DECLARE json_data json;
BEGIN
json_data := "Json";
INSERT INTO macrofauna.sample (name, extraction_method_id)
VALUES ((json_data->>'name')::character varying, (json_data->>'extraction_method_id')::integer)
RETURNING id INTO v_id;
RETURN v_id;
END $function$
*/
}
/**
* @function macrofauna_sample_d
* @memberof zzglc
* @description Macrofauna sample d
* @param {integer} Key
* @returns {void}
*/
function macrofauna_sample_d() {
/*
CREATE OR REPLACE FUNCTION zzglc.macrofauna_sample_d("Key" integer)
RETURNS void
LANGUAGE plpgsql
AS $function$
BEGIN
DELETE FROM macrofauna.sample WHERE id = "Key";
END;
$function$
*/
}
/**
* @function macrofauna_sample_r
* @memberof zzglc
* @description Macrofauna sample r
* @returns {Object} integer idcharacter_varying nameinteger extraction_method_idcharacter_varying extraction_method_id_val
*/
function macrofauna_sample_r() {
/*
CREATE OR REPLACE FUNCTION zzglc.macrofauna_sample_r()
RETURNS TABLE(id integer, name character varying, extraction_method_id integer, extraction_method_id_val character varying)
LANGUAGE plpgsql
AS $function$
BEGIN
RETURN QUERY (
SELECT t.id, t.name, t.extraction_method_id, extraction_method_id.name
FROM macrofauna.sample t
LEFT JOIN macrofauna.extraction_method extraction_method_id ON extraction_method_id.id = t.extraction_method_id
);
END $function$
*/
}
/**
* @function macrofauna_sample_u
* @memberof zzglc
* @description Macrofauna sample u
* @param {character_varying} Json
* @returns {void}
*/
function macrofauna_sample_u() {
/*
CREATE OR REPLACE FUNCTION zzglc.macrofauna_sample_u("Json" character varying)
RETURNS void
LANGUAGE plpgsql
AS $function$
DECLARE json_data json;
BEGIN
json_data := "Json";
UPDATE macrofauna.sample SET
name = (json_data->>'name')::character varying,
extraction_method_id = (json_data->>'extraction_method_id')::integer
WHERE id = (json_data->>'id')::integer;
END $function$
*/
}
/**
* @function meta_app_c
* @memberof zzglc
* @description Meta app c
* @param {character_varying} Json
* @returns {integer}
*/
function meta_app_c() {
/*
CREATE OR REPLACE FUNCTION zzglc.meta_app_c("Json" character varying)
RETURNS integer
LANGUAGE plpgsql
AS $function$
DECLARE v_id integer;
DECLARE json_data json;
BEGIN
json_data := "Json";
INSERT INTO meta.app (agreement, privacy_policy, terms_of_service, contact_provider_id, contact_mail)
VALUES ((json_data->>'agreement')::text, (json_data->>'privacy_policy')::text, (json_data->>'terms_of_service')::text, (json_data->>'contact_provider_id')::integer, (json_data->>'contact_mail')::character varying)
RETURNING id INTO v_id;
RETURN v_id;
END $function$
*/
}
/**
* @function meta_app_d
* @memberof zzglc
* @description Meta app d
* @param {integer} Key
* @returns {void}
*/
function meta_app_d() {
/*
CREATE OR REPLACE FUNCTION zzglc.meta_app_d("Key" integer)
RETURNS void
LANGUAGE plpgsql
AS $function$
BEGIN
DELETE FROM meta.app WHERE id = "Key";
END;
$function$
*/
}
/**
* @function meta_app_r
* @memberof zzglc
* @description Meta app r
* @returns {Object} integer idtext agreementtext privacy_policytext terms_of_serviceinteger general_email_provider__contact_provider_idcharacter_varying contact_mailcharacter_varying general_email_provider__contact_provider_id_val
*/
function meta_app_r() {
/*
CREATE OR REPLACE FUNCTION zzglc.meta_app_r()
RETURNS TABLE(id integer, agreement text, privacy_policy text, terms_of_service text, general_email_provider__contact_provider_id integer, contact_mail character varying, general_email_provider__contact_provider_id_val character varying)
LANGUAGE plpgsql
AS $function$
BEGIN
RETURN QUERY (
SELECT t.id, t.agreement, t.privacy_policy, t.terms_of_service, t.contact_provider_id, t.contact_mail, contact_provider_id.name
FROM meta.app t
LEFT JOIN general.email_provider contact_provider_id ON contact_provider_id.id = t.contact_provider_id
ORDER BY 2
);
END $function$
*/
}
/**
* @function meta_app_u
* @memberof zzglc
* @description Meta app u
* @param {character_varying} Json
* @returns {void}
*/
function meta_app_u() {
/*
CREATE OR REPLACE FUNCTION zzglc.meta_app_u("Json" character varying)
RETURNS void
LANGUAGE plpgsql
AS $function$
DECLARE json_data json;
BEGIN
json_data := "Json";
UPDATE meta.app SET
agreement = (json_data->>'agreement')::text,
privacy_policy = (json_data->>'privacy_policy')::text,
terms_of_service = (json_data->>'terms_of_service')::text,
contact_provider_id = (json_data->>'contact_provider_id')::integer,
contact_mail = (json_data->>'contact_mail')::character varying
WHERE id = (json_data->>'id')::integer;
END $function$
*/
}
/**
* @function meta_help_c
* @memberof zzglc
* @description Meta help c
* @param {character_varying} Json
* @returns {void}
*/
function meta_help_c() {
/*
CREATE OR REPLACE FUNCTION zzglc.meta_help_c("Json" character varying)
RETURNS void
LANGUAGE plpgsql
AS $function$
BEGIN
INSERT INTO meta.help (
name
)
SELECT
U.name
FROM
json_to_record("Json"::json) U (
name character varying
)
;
END $function$
*/
}
/**
* @function meta_help_d
* @memberof zzglc
* @description Meta help d
* @param {integer} Key
* @returns {void}
*/
function meta_help_d() {
/*
CREATE OR REPLACE FUNCTION zzglc.meta_help_d("Key" integer)
RETURNS void
LANGUAGE plpgsql
AS $function$
BEGIN
DELETE FROM meta.help
WHERE id = "Key";
END $function$
*/
}
/**
* @function meta_help_lang_c
* @memberof zzglc
* @description Meta help lang c
* @param {character_varying} Json
* @returns {void}
*/
function meta_help_lang_c() {
/*
CREATE OR REPLACE FUNCTION zzglc.meta_help_lang_c("Json" character varying)
RETURNS void
LANGUAGE plpgsql
AS $function$
BEGIN
INSERT INTO meta.help_lang (
help_id,
lang_id,
value
)
SELECT
U.help_id,
U.lang_id,
U.value
FROM
json_to_record("Json"::json) U (
help_id integer,
lang_id integer,
value text
)
;
END $function$
*/
}
/**
* @function meta_help_lang_d
* @memberof zzglc
* @description Meta help lang d
* @param {integer} Key
* @returns {void}
*/
function meta_help_lang_d() {
/*
CREATE OR REPLACE FUNCTION zzglc.meta_help_lang_d("Key" integer)
RETURNS void
LANGUAGE plpgsql
AS $function$
BEGIN
DELETE FROM meta.help_lang
WHERE id = "Key";
END $function$
*/
}
/**
* @function meta_help_lang_r
* @memberof zzglc
* @description Meta help lang r
* @param {integer} LangId
* @returns {Object}
* @property {integer} id
* @property {integer} help_id
* @property {integer} lang_id
* @property {character_varying} value
* @property {character_varying} meta_help_id_val
* @property {character_varying} meta_lang_id_val
*/
function meta_help_lang_r() {
/*
CREATE OR REPLACE FUNCTION zzglc.meta_help_lang_r("Params" text)
RETURNS TABLE(id integer, help_id integer, lang_id integer, value text, help_id_val character varying, lang_id_val character varying)
LANGUAGE plpgsql
AS $function$
DECLARE v_lang_id integer;
BEGIN
v_lang_id = (("Params"::json)->>'lang_id')::integer;
RETURN QUERY
SELECT
COALESCE (t.id, -row_number() over (order by help_id_t.name))::int id
, help_id_t.id help_id
, v_lang_id lang_id
, COALESCE(t.value, t1.value, help_id_t.name)
, help_id_t.name::VARCHAR AS help_id_val
, lang_id_t.name::VARCHAR AS lang_id_val
--, (t.id is not null) translated
FROM meta.help help_id_t
LEFT JOIN meta.help_lang t ON help_id_t.id = t.help_id AND t.lang_id = v_lang_id
LEFT JOIN meta.lang lang_id_t ON lang_id_t.id = t.lang_id
LEFT JOIN meta.help_lang t1 ON t1.lang_id = 1 AND t1.help_id = help_id_t.id
ORDER BY help_id_t.name
;
END
$function$
*/
}
/**
* @function meta_help_lang_u
* @memberof zzglc
* @description Meta help lang u
* @param {character_varying} Json
* @returns {void}
*/
function meta_help_lang_u() {
/*
CREATE OR REPLACE FUNCTION zzglc.meta_help_lang_u("Json" character varying)
RETURNS void
LANGUAGE plpgsql
AS $function$
BEGIN
CREATE TEMP TABLE j AS
SELECT * FROM json_to_record("Json"::json) AS U (
id integer,
help_id integer,
lang_id integer,
value text
);
UPDATE meta.help_lang t
SET help_id = U.help_id,
lang_id = U.lang_id,
value = U.value
FROM json_to_record("Json"::json) AS U (
id integer,
help_id integer,
lang_id integer,
value text
)
WHERE U.id = t.id;
INSERT INTO meta.help_lang (help_id, lang_id, value)
SELECT help_id, lang_id, value FROM j WHERE id < 0;
DROP TABLE j;
END
$function$
*/
}
/**
* @function meta_help_r
* @memberof zzglc
* @description Meta help r
* @returns {Object}
* @property {integer} id
* @property {character_varying} name
*/
function meta_help_r() {
/*
CREATE OR REPLACE FUNCTION zzglc.meta_help_r()
RETURNS TABLE(id integer, name character varying)
LANGUAGE plpgsql
AS $function$
BEGIN
RETURN QUERY
SELECT
t.id, t.name
FROM meta.help t
;
END $function$
*/
}
/**
* @function meta_help_u
* @memberof zzglc
* @description Meta help u
* @param {character_varying} Json
* @returns {void}
*/
function meta_help_u() {
/*
CREATE OR REPLACE FUNCTION zzglc.meta_help_u("Json" character varying)
RETURNS void
LANGUAGE plpgsql
AS $function$
DECLARE v_row_count INTEGER;
BEGIN
UPDATE meta.help t
SET name = U.name
FROM json_to_record("Json"::json) AS U (
id integer,
name character varying(255)
)
WHERE U.id = t.id
;
END $function$
*/
}
/**
* @function meta_i18n_c
* @memberof zzglc
* @description Meta i18n c
* @param {character_varying} Json
* @returns {void}
*/
function meta_i18n_c() {
/*
CREATE OR REPLACE FUNCTION zzglc.meta_i18n_c("Json" character varying)
RETURNS void
LANGUAGE plpgsql
AS $function$
BEGIN
INSERT INTO meta.i18n (
key
)
SELECT
U.key
FROM
json_to_record("Json"::json) U (
key character varying
)
;
END $function$
*/
}
/**
* @function meta_i18n_d
* @memberof zzglc
* @description Meta i18n d
* @param {integer} Key
* @returns {void}
*/
function meta_i18n_d() {
/*
CREATE OR REPLACE FUNCTION zzglc.meta_i18n_d("Key" integer)
RETURNS void
LANGUAGE plpgsql
AS $function$
BEGIN
DELETE FROM meta.i18n
WHERE id = "Key";
END $function$
*/
}
/**
* @function meta_i18n_lang_c
* @memberof zzglc
* @description Meta i18n lang c
* @param {character_varying} Json
* @returns {void}
*/
function meta_i18n_lang_c() {
/*
CREATE OR REPLACE FUNCTION zzglc.meta_i18n_lang_c("Json" character varying)
RETURNS void
LANGUAGE plpgsql
AS $function$
BEGIN
INSERT INTO meta.i18n_lang (
i18n_id,
lang_id,
value
)
SELECT
U.i18n_id,
U.lang_id,
U.value
FROM
json_to_record("Json"::json) U (
i18n_id integer,
lang_id integer,
value character varying(255)
)
;
END $function$
*/
}
/**
* @function meta_i18n_lang_d
* @memberof zzglc
* @description Meta i18n lang d
* @param {integer} Key
* @returns {void}
*/
function meta_i18n_lang_d() {
/*
CREATE OR REPLACE FUNCTION zzglc.meta_i18n_lang_d("Key" integer)
RETURNS void
LANGUAGE plpgsql
AS $function$
BEGIN
DELETE FROM meta.i18n_lang
WHERE id = "Key";
END $function$
*/
}
/**
* @function meta_i18n_lang_r
* @memberof zzglc
* @description Meta i18n lang r
* @param {integer} LangId
* @returns {Object}
* @property {integer} id
* @property {integer} i18n_id
* @property {integer} lang_id
* @property {character_varying} value
* @property {character_varying} i18n_id_val
* @property {character_varying} lang_id_val
*/
function meta_i18n_lang_r() {
/*
CREATE OR REPLACE FUNCTION zzglc.meta_i18n_lang_r("Params" text)
RETURNS TABLE(id integer, i18n_id integer, lang_id integer, value character varying, i18n_id_val character varying, lang_id_val character varying)
LANGUAGE plpgsql
AS $function$
DECLARE v_lang_id integer;
BEGIN
v_lang_id = (("Params"::json)->>'lang_id')::integer;
RETURN QUERY
SELECT
COALESCE (t.id, -row_number() over (order by i18n_id_t.key))::int id
, i18n_id_t.id i18n_id
, v_lang_id lang_id
, COALESCE(t.value, t1.value, i18n_id_t.key)::VARCHAR AS value
, i18n_id_t.key::VARCHAR AS i18n_id_val
, lang_id_t.name::VARCHAR AS lang_id_val
--, (t.id is not null) translated
FROM meta.i18n i18n_id_t
LEFT JOIN meta.i18n_lang t ON i18n_id_t.id = t.i18n_id AND t.lang_id = v_lang_id
LEFT JOIN meta.lang lang_id_t ON lang_id_t.id = t.lang_id
LEFT JOIN meta.i18n_lang t1 ON t1.lang_id = 1 AND t1.i18n_id = i18n_id_t.id
ORDER BY i18n_id_t.key
;
END
$function$
*/
}
/**
* @function meta_i18n_lang_u
* @memberof zzglc
* @description Meta i18n lang u
* @param {character_varying} Json
* @returns {void}
*/
function meta_i18n_lang_u() {
/*
CREATE OR REPLACE FUNCTION zzglc.meta_i18n_lang_u("Json" character varying)
RETURNS void
LANGUAGE plpgsql
AS $function$
BEGIN
CREATE TEMP TABLE j AS
SELECT * FROM json_to_record("Json"::json) AS U (
id integer,
i18n_id integer,
lang_id integer,
value character varying(255)
);
UPDATE meta.i18n_lang t
SET i18n_id = j.i18n_id,
lang_id = j.lang_id,
value = j.value
FROM j
WHERE j.id = t.id;
INSERT INTO meta.i18n_lang (i18n_id, lang_id, value)
SELECT i18n_id, lang_id, value FROM j WHERE id < 0;
DROP TABLE j;
END
$function$
*/
}
/**
* @function meta_i18n_r
* @memberof zzglc
* @description Meta i18n r
* @returns {Object}
* @property {integer} id
* @property {character_varying} key
*/
function meta_i18n_r() {
/*
CREATE OR REPLACE FUNCTION zzglc.meta_i18n_r()
RETURNS TABLE(id integer, key character varying)
LANGUAGE plpgsql
AS $function$
BEGIN
RETURN QUERY
SELECT
t.id, t.key
FROM meta.i18n t
ORDER BY t.key
;
END $function$
*/
}
/**
* @function meta_i18n_u
* @memberof zzglc
* @description Meta i18n u
* @param {character_varying} Json
* @returns {void}
*/
function meta_i18n_u() {
/*
CREATE OR REPLACE FUNCTION zzglc.meta_i18n_u("Json" character varying)
RETURNS void
LANGUAGE plpgsql
AS $function$
DECLARE v_row_count INTEGER;
BEGIN
UPDATE meta.i18n t
SET key = U.key
FROM json_to_record("Json"::json) AS U (
id integer,
key character varying(255)
)
WHERE U.id = t.id
;
END $function$
*/
}
/**
* @function meta_import_detail_c
* @memberof zzglc
* @description Meta import detail c
* @param {character_varying} Json
* @returns {integer}
*/
function meta_import_detail_c() {
/*
CREATE OR REPLACE FUNCTION zzglc.meta_import_detail_c("Json" character varying)
RETURNS integer
LANGUAGE plpgsql
AS $function$
DECLARE v_id integer;
DECLARE json_data json;
BEGIN
json_data := "Json";
INSERT INTO meta.import_detail (import_master_id, col_name, target_schema, target_table, target_column, col_type, is_key, is_fk, as_row, target_column_list, source_column_list, joins, split, ignore, name_match, order_no, ignore_in_master, constant_value, from_additional_join)
VALUES ((json_data->>'import_master_id')::integer, (json_data->>'col_name')::character varying, (json_data->>'target_schema')::character varying, (json_data->>'target_table')::character varying, (json_data->>'target_column')::character varying, (json_data->>'col_type')::character varying, (json_data->>'is_key')::boolean, (json_data->>'is_fk')::boolean, (json_data->>'as_row')::boolean, (json_data->>'target_column_list')::character varying, (json_data->>'source_column_list')::character varying, (json_data->>'joins')::character varying, (json_data->>'split')::boolean, (json_data->>'ignore')::boolean, (json_data->>'name_match')::character varying, (json_data->>'order_no')::integer, (json_data->>'ignore_in_master')::boolean, (json_data->>'constant_value')::character varying, (json_data->>'from_additional_join')::boolean)
RETURNING id INTO v_id;
RETURN v_id;
END $function$
*/
}
/**
* @function meta_import_detail_d
* @memberof zzglc
* @description Meta import detail d
* @param {integer} Key
* @returns {void}
*/
function meta_import_detail_d() {
/*
CREATE OR REPLACE FUNCTION zzglc.meta_import_detail_d("Key" integer)
RETURNS void
LANGUAGE plpgsql
AS $function$
BEGIN
DELETE FROM meta.import_detail WHERE id = "Key";
END;
$function$
*/
}
/**
* @function meta_import_detail_r
* @memberof zzglc
* @description Meta import detail r
* @param {integer} Key
* @returns {Object} integer idinteger meta_import_master__import_master_idcharacter_varying col_namecharacter_varying target_schemacharacter_varying target_tablecharacter_varying target_columncharacter_varying col_typeboolean is_keyboolean is_fkboolean as_rowcharacter_varying target_column_listcharacter_varying source_column_listcharacter_varying joinsboolean splitboolean ignorecharacter_varying name_matchinteger order_noboolean ignore_in_mastercharacter_varying constant_valueboolean from_additional_joincharacter_varying meta_import_master__import_master_id_val
*/
function meta_import_detail_r() {
/*
CREATE OR REPLACE FUNCTION zzglc.meta_import_detail_r("Key" integer)
RETURNS TABLE(id integer, meta_import_master__import_master_id integer, col_name character varying, target_schema character varying, target_table character varying, target_column character varying, col_type character varying, is_key boolean, is_fk boolean, as_row boolean, target_column_list character varying, source_column_list character varying, joins character varying, split boolean, ignore boolean, name_match character varying, order_no integer, ignore_in_master boolean, constant_value character varying, from_additional_join boolean, meta_import_master__import_master_id_val character varying)
LANGUAGE plpgsql
AS $function$
BEGIN
RETURN QUERY (
SELECT t.id, t.import_master_id, t.col_name, t.target_schema, t.target_table, t.target_column, t.col_type, t.is_key, t.is_fk, t.as_row, t.target_column_list, t.source_column_list, t.joins, t.split, t.ignore, t.name_match, t.order_no, t.ignore_in_master, t.constant_value, t.from_additional_join, import_master_id.schema_name
FROM meta.import_detail t
LEFT JOIN meta.import_master import_master_id ON import_master_id.id = t.import_master_id
WHERE t.import_master_id = "Key"
ORDER BY 2
);
END $function$
*/
}
/**
* @function meta_import_detail_r_overload
* @overload meta_import_detail_r
* @memberof zzglc
* @description Meta import detail r
* @returns {Object} integer idinteger meta_import_master__import_master_idcharacter_varying col_namecharacter_varying target_schemacharacter_varying target_tablecharacter_varying target_columncharacter_varying col_typeboolean is_keyboolean is_fkboolean as_rowcharacter_varying target_column_listcharacter_varying source_column_listcharacter_varying joinsboolean splitboolean ignorecharacter_varying name_matchinteger order_noboolean ignore_in_mastercharacter_varying constant_valueboolean from_additional_joincharacter_varying meta_import_master__import_master_id_val
*/
function meta_import_detail_r_overload() {
/*
CREATE OR REPLACE FUNCTION zzglc.meta_import_detail_r()
RETURNS TABLE(id integer, meta_import_master__import_master_id integer, col_name character varying, target_schema character varying, target_table character varying, target_column character varying, col_type character varying, is_key boolean, is_fk boolean, as_row boolean, target_column_list character varying, source_column_list character varying, joins character varying, split boolean, ignore boolean, name_match character varying, order_no integer, ignore_in_master boolean, constant_value character varying, from_additional_join boolean, meta_import_master__import_master_id_val character varying)
LANGUAGE plpgsql
AS $function$
BEGIN
RETURN QUERY (
SELECT t.id, t.import_master_id, t.col_name, t.target_schema, t.target_table, t.target_column, t.col_type, t.is_key, t.is_fk, t.as_row, t.target_column_list, t.source_column_list, t.joins, t.split, t.ignore, t.name_match, t.order_no, t.ignore_in_master, t.constant_value, t.from_additional_join, import_master_id.schema_name
FROM meta.import_detail t
LEFT JOIN meta.import_master import_master_id ON import_master_id.id = t.import_master_id
ORDER BY 2
);
END $function$
*/
}
/**
* @function meta_import_detail_u
* @memberof zzglc
* @description Meta import detail u
* @param {character_varying} Json
* @returns {void}
*/
function meta_import_detail_u() {
/*
CREATE OR REPLACE FUNCTION zzglc.meta_import_detail_u("Json" character varying)
RETURNS void
LANGUAGE plpgsql
AS $function$
DECLARE json_data json;
BEGIN
json_data := "Json";
UPDATE meta.import_detail SET
import_master_id = (json_data->>'import_master_id')::integer,
col_name = (json_data->>'col_name')::character varying,
target_schema = (json_data->>'target_schema')::character varying,
target_table = (json_data->>'target_table')::character varying,
target_column = (json_data->>'target_column')::character varying,
col_type = (json_data->>'col_type')::character varying,
is_key = (json_data->>'is_key')::boolean,
is_fk = (json_data->>'is_fk')::boolean,
as_row = (json_data->>'as_row')::boolean,
target_column_list = (json_data->>'target_column_list')::character varying,
source_column_list = (json_data->>'source_column_list')::character varying,
joins = (json_data->>'joins')::character varying,
split = (json_data->>'split')::boolean,
ignore = (json_data->>'ignore')::boolean,
name_match = (json_data->>'name_match')::character varying,
order_no = (json_data->>'order_no')::integer,
ignore_in_master = (json_data->>'ignore_in_master')::boolean,
constant_value = (json_data->>'constant_value')::character varying,
from_additional_join = (json_data->>'from_additional_join')::boolean
WHERE id = (json_data->>'id')::integer;
END $function$
*/
}
/**
* @function meta_import_master_c
* @memberof zzglc
* @description Meta import master c
* @param {character_varying} Json
* @returns {integer}
*/
function meta_import_master_c() {
/*
CREATE OR REPLACE FUNCTION zzglc.meta_import_master_c("Json" character varying)
RETURNS integer
LANGUAGE plpgsql
AS $function$
DECLARE v_id integer;
DECLARE json_data json;
BEGIN
json_data := "Json";
INSERT INTO meta.import_master (schema_name, table_name, sheet, import_name, data_date, constant_value, preprocess, additional_column_list, additional_joins)
VALUES ((json_data->>'schema_name')::character varying, (json_data->>'table_name')::character varying, (json_data->>'sheet')::character varying, (json_data->>'import_name')::character varying, (json_data->>'data_date')::character varying, (json_data->>'constant_value')::character varying, (json_data->>'preprocess')::character varying, (json_data->>'additional_column_list')::character varying, (json_data->>'additional_joins')::character varying)
RETURNING id INTO v_id;
RETURN v_id;
END $function$
*/
}
/**
* @function meta_import_master_d
* @memberof zzglc
* @description Meta import master d
* @param {integer} Key
* @returns {void}
*/
function meta_import_master_d() {
/*
CREATE OR REPLACE FUNCTION zzglc.meta_import_master_d("Key" integer)
RETURNS void
LANGUAGE plpgsql
AS $function$
BEGIN
DELETE FROM meta.import_master WHERE id = "Key";
END;
$function$
*/
}
/**
* @function meta_import_master_r
* @memberof zzglc
* @description Meta import master r
* @returns {Object} integer idcharacter_varying schema_namecharacter_varying table_namecharacter_varying sheetcharacter_varying import_namecharacter_varying data_datecharacter_varying constant_valuecharacter_varying preprocesscharacter_varying additional_column_listcharacter_varying additional_joins
*/
function meta_import_master_r() {
/*
CREATE OR REPLACE FUNCTION zzglc.meta_import_master_r()
RETURNS TABLE(id integer, schema_name character varying, table_name character varying, sheet character varying, import_name character varying, data_date character varying, constant_value character varying, preprocess character varying, additional_column_list character varying, additional_joins character varying)
LANGUAGE plpgsql
AS $function$
BEGIN
RETURN QUERY (
SELECT t.id, t.schema_name, t.table_name, t.sheet, t.import_name, t.data_date, t.constant_value, t.preprocess, t.additional_column_list, t.additional_joins
FROM meta.import_master t
ORDER BY 2, 3
);
END $function$
*/
}
/**
* @function meta_import_master_u
* @memberof zzglc
* @description Meta import master u
* @param {character_varying} Json
* @returns {void}
*/
function meta_import_master_u() {
/*
CREATE OR REPLACE FUNCTION zzglc.meta_import_master_u("Json" character varying)
RETURNS void
LANGUAGE plpgsql
AS $function$
DECLARE json_data json;
BEGIN
json_data := "Json";
UPDATE meta.import_master SET
schema_name = (json_data->>'schema_name')::character varying,
table_name = (json_data->>'table_name')::character varying,
sheet = (json_data->>'sheet')::character varying,
import_name = (json_data->>'import_name')::character varying,
data_date = (json_data->>'data_date')::character varying,
constant_value = (json_data->>'constant_value')::character varying,
preprocess = (json_data->>'preprocess')::character varying,
additional_column_list = (json_data->>'additional_column_list')::character varying,
additional_joins = (json_data->>'additional_joins')::character varying
WHERE id = (json_data->>'id')::integer;
END $function$
*/
}
/**
* @function meta_lang_c
* @memberof zzglc
* @description Meta lang c
* @param {character_varying} Json
* @returns {integer}
*/
function meta_lang_c() {
/*
CREATE OR REPLACE FUNCTION zzglc.meta_lang_c("Json" character varying)
RETURNS integer
LANGUAGE plpgsql
AS $function$
DECLARE v_id integer;
BEGIN
INSERT INTO meta.lang (
id,
name,
tag,
short_tag
)
SELECT
U.id,
U.name,
U.tag,
U.short_tag
FROM
json_to_record("Json"::json) U (
id integer,
name character varying(255),
tag character varying(15),
short_tag character(2)
)
RETURNING id INTO v_id;
RETURN v_id;
END $function$
*/
}
/**
* @function meta_lang_d
* @memberof zzglc
* @description Meta lang d
* @param {integer} Key
* @returns {void}
*/
function meta_lang_d() {
/*
CREATE OR REPLACE FUNCTION zzglc.meta_lang_d("Key" integer)
RETURNS void
LANGUAGE plpgsql
AS $function$
BEGIN
DELETE FROM meta.lang
WHERE id = "Key";
END $function$
*/
}
/**
* @function meta_lang_r
* @memberof zzglc
* @description Meta lang r
* @returns {Object}
* @property {integer} id
* @property {character_varying} name
* @property {character_varying} tag
* @property {timestamp_without_time_zone} time_modified
* @property {character} short_tag
*/
function meta_lang_r() {
/*
CREATE OR REPLACE FUNCTION zzglc.meta_lang_r()
RETURNS TABLE(id integer, name character varying, tag character varying, time_modified timestamp without time zone, short_tag character)
LANGUAGE plpgsql
AS $function$
BEGIN
RETURN QUERY
SELECT
t.id, t.name, t.tag, t.time_modified, t.short_tag
FROM meta.lang t
ORDER BY t.name
;
END $function$
*/
}
/**
* @function meta_lang_u
* @memberof zzglc
* @description Meta lang u
* @param {character_varying} Json
* @returns {void}
*/
function meta_lang_u() {
/*
CREATE OR REPLACE FUNCTION zzglc.meta_lang_u("Json" character varying)
RETURNS void
LANGUAGE plpgsql
AS $function$
DECLARE v_row_count INTEGER;
BEGIN
UPDATE meta.lang t
SET name = U.name,
tag = U.tag,
short_tag = U.short_tag
FROM json_to_record("Json"::json) AS U (
id integer,
name character varying(255),
tag character varying(15),
time_modified timestamp(6) without time zone,
short_tag character(2)
)
WHERE U.id = t.id
AND t.time_modified = U.time_modified;
GET DIAGNOSTICS v_row_count = ROW_COUNT;
IF v_row_count = 0 THEN
SELECT meta.raise_error(2);
END IF
;
END $function$
*/
}
/**
* @function meta_news_c
* @memberof zzglc
* @description Meta news c
* @param {character_varying} Json
* @returns {void}
*/
function meta_news_c() {
/*
CREATE OR REPLACE FUNCTION zzglc.meta_news_c("Json" character varying)
RETURNS void
LANGUAGE plpgsql
AS $function$
BEGIN
INSERT INTO meta.news (
name,
active,
user_modified_id,
time_created
)
SELECT
U.name,
U.active,
auth.get_context_person_id(),
now()
FROM
json_to_record("Json"::json) U (
name character varying(255),
active boolean
)
;
END $function$
*/
}
/**
* @function meta_news_d
* @memberof zzglc
* @description Meta news d
* @param {integer} Key
* @returns {void}
*/
function meta_news_d() {
/*
CREATE OR REPLACE FUNCTION zzglc.meta_news_d("Key" integer)
RETURNS void
LANGUAGE plpgsql
AS $function$
BEGIN
DELETE FROM meta.news
WHERE id = "Key";
END $function$
*/
}
/**
* @function meta_news_lang_c
* @memberof zzglc
* @description Meta news lang c
* @param {character_varying} Json
* @returns {integer}
*/
function meta_news_lang_c() {
/*
CREATE OR REPLACE FUNCTION zzglc.meta_news_lang_c("Json" character varying)
RETURNS integer
LANGUAGE plpgsql
AS $function$
DECLARE v_id integer;
DECLARE json_data json;
BEGIN
json_data := "Json";
INSERT INTO meta.news_lang (lang_id, text, extended_text, time_modified, user_modified, time_created, title, news_id)
VALUES ((json_data->>'lang_id')::integer, (json_data->>'text')::character varying, (json_data->>'extended_text')::character varying, (json_data->>'time_modified')::timestamp with time zone, (json_data->>'user_modified')::integer, (json_data->>'time_created')::timestamp with time zone, (json_data->>'title')::character varying, (json_data->>'news_id')::integer)
RETURNING id INTO v_id;
RETURN v_id;
END $function$
*/
}
/**
* @function meta_news_lang_d
* @memberof zzglc
* @description Meta news lang d
* @param {integer} Key
* @returns {void}
*/
function meta_news_lang_d() {
/*
CREATE OR REPLACE FUNCTION zzglc.meta_news_lang_d("Key" integer)
RETURNS void
LANGUAGE plpgsql
AS $function$
BEGIN
DELETE FROM meta.news_lang WHERE id = "Key";
END;
$function$
*/
}
/**
* @function meta_news_lang_r
* @memberof zzglc
* @description Meta news lang r
* @param {integer} Key
* @returns {Object} integer idinteger news_idinteger lang_idcharacter_varying titlecharacter_varying textcharacter_varying extended_textcharacter_varying news_id_valcharacter_varying lang_id_val
*/
function meta_news_lang_r() {
/*
CREATE OR REPLACE FUNCTION zzglc.meta_news_lang_r("Key" integer)
RETURNS TABLE(id integer, news_id integer, lang_id integer, title character varying, text character varying, extended_text character varying, news_id_val character varying, lang_id_val character varying)
LANGUAGE plpgsql
AS $function$
BEGIN
RETURN QUERY (
-- SELECT t.id, t.lang_id, t.text, t.extended_text, t.time_modified, t.user_modified_id, t.time_created, t.title, t.news_id, lang_id.name, user_modified_id.email, news_id.name
-- FROM meta.news_lang t
-- LEFT JOIN meta.lang lang_id ON lang_id.id = t.lang_id
-- LEFT JOIN auth.person user_modified_id ON user_modified_id.id = t.user_modified_id
-- LEFT JOIN meta.news news_id ON news_id.id = t.news_id
-- WHERE t.news_id = "Key" AND (t.lang_id = auth.get_context_lang_id() OR t.lang_id is null)
-- ORDER BY 2
SELECT
COALESCE (t.id, -row_number() over (order by news_id_t.time_modified))::int id
, news_id_t.id news_id
, auth.get_context_lang_id() lang_id
, COALESCE(t.title, t1.title, news_id_t.name)::VARCHAR AS title
, COALESCE(t.text, t1.text, news_id_t.name)::VARCHAR AS text
, COALESCE(t.extended_text, t1.extended_text)::VARCHAR AS extended_text
, news_id_t.name::VARCHAR AS news_id_val
, lang_id_t.name::VARCHAR AS lang_id_val
--, (t.id is not null) translated
FROM meta.news news_id_t
LEFT JOIN meta.news_lang t ON news_id_t.id = t.news_id AND t.lang_id = auth.get_context_lang_id()
LEFT JOIN meta.lang lang_id_t ON lang_id_t.id = t.lang_id
LEFT JOIN meta.news_lang t1 ON t1.lang_id = 1 AND t1.news_id = news_id_t.id
WHERE news_id_t.id = "Key"
);
END $function$
*/
}
/**
* @function meta_news_lang_r_overload
* @overload meta_news_lang_r
* @memberof zzglc
* @description Meta news lang r
* @param {integer} LangId
* @returns {Object}
* @property {integer} id
* @property {integer} news_id
* @property {integer} lang_id
* @property {character_varying} value
* @property {character_varying} news_id_val
* @property {character_varying} lang_id_val
*/
function meta_news_lang_r_overload() {
/*
CREATE OR REPLACE FUNCTION zzglc.meta_news_lang_r("Params" text)
RETURNS TABLE(id integer, news_id integer, lang_id integer, title character varying, text character varying, extended_text character varying, news_id_val character varying, lang_id_val character varying)
LANGUAGE plpgsql
AS $function$
DECLARE v_lang_id integer;
BEGIN
v_lang_id := (("Params"::json)->>'lang_id') :: INTEGER;
RETURN QUERY
SELECT
COALESCE (t.id, -row_number() over (order by news_id_t.time_modified))::int id
, news_id_t.id news_id
, v_lang_id lang_id
, COALESCE(t.title, t1.title, news_id_t.name)::VARCHAR AS title
, COALESCE(t.text, t1.text, news_id_t.name)::VARCHAR AS text
, COALESCE(t.extended_text, t1.extended_text)::VARCHAR AS extended_text
, news_id_t.name::VARCHAR AS news_id_val
, lang_id_t.name::VARCHAR AS lang_id_val
--, (t.id is not null) translated
FROM meta.news news_id_t
LEFT JOIN meta.news_lang t ON news_id_t.id = t.news_id AND t.lang_id = v_lang_id
LEFT JOIN meta.lang lang_id_t ON lang_id_t.id = t.lang_id
LEFT JOIN meta.news_lang t1 ON t1.lang_id = 1 AND t1.news_id = news_id_t.id
ORDER BY news_id_t.time_modified DESC
;
END
$function$
*/
}
/**
* @function meta_news_lang_r_overload
* @overload meta_news_lang_r
* @memberof zzglc
* @description Meta news lang r
* @returns {Object} integer idinteger meta_lang__lang_idcharacter_varying textcharacter_varying extended_texttimestamp_with_time_zone time_modifiedinteger auth_person__user_modified_idtimestamp_with_time_zone time_createdcharacter_varying titleinteger meta_news__news_idcharacter_varying meta_lang__lang_id_valcharacter_varying auth_person__user_modified_id_valcharacter_varying meta_news__news_id_val
*/
function meta_news_lang_r_overload_overload() {
/*
CREATE OR REPLACE FUNCTION zzglc.meta_news_lang_r()
RETURNS TABLE(id integer, meta_lang__lang_id integer, text character varying, extended_text character varying, time_modified timestamp with time zone, auth_person__user_modified_id integer, time_created timestamp with time zone, title character varying, meta_news__news_id integer, meta_lang__lang_id_val character varying, auth_person__user_modified_id_val character varying, meta_news__news_id_val character varying)
LANGUAGE plpgsql
AS $function$
BEGIN
RETURN QUERY (
SELECT t.id, t.lang_id, t.text, t.extended_text, t.time_modified, t.user_modified_id, t.time_created, t.title, t.news_id, lang_id.name, user_modified.email, news_id.name
FROM meta.news_lang t
LEFT JOIN meta.lang lang_id ON lang_id.id = t.lang_id
LEFT JOIN auth.person user_modified ON user_modified.id = t.user_modified_id
LEFT JOIN meta.news news_id ON news_id.id = t.news_id
ORDER BY 2
);
END $function$
*/
}
/**
* @function meta_news_lang_u
* @memberof zzglc
* @description Meta news lang u
* @param {character_varying} Json
* @returns {integer}
*/
function meta_news_lang_u() {
/*
CREATE OR REPLACE FUNCTION zzglc.meta_news_lang_u("Json" character varying)
RETURNS integer
LANGUAGE plpgsql
AS $function$
DECLARE v_id integer;
DECLARE json_data json;
BEGIN
json_data := "Json";
v_id := (json_data->>'id')::integer;
IF v_id < 0 THEN
INSERT INTO meta.news_lang(
lang_id, text, extended_text, title, news_id)
VALUES ((json_data->>'lang_id')::integer,
(json_data->>'text')::character varying,
(json_data->>'extended_text')::character varying,
(json_data->>'title')::character varying,
(json_data->>'news_id')::integer)
RETURNING id INTO v_id;
ELSE
UPDATE meta.news_lang SET
lang_id = (json_data->>'lang_id')::integer,
text = (json_data->>'text')::character varying,
extended_text = (json_data->>'extended_text')::character varying,
title = (json_data->>'title')::character varying,
news_id = (json_data->>'news_id')::integer
WHERE id = v_id;
END IF;
RETURN v_id;
END $function$
*/
}
/**
* @function meta_news_r
* @memberof zzglc
* @description Meta news r
* @returns {Object}
* @property {integer} id
* @property {character_varying} name
* @property {boolean} active
* @property {timestamp_without_time_zone} time_modified
* @property {integer} user_modified_id
* @property {timestamp_without_time_zone} time_created
* @property {character_varying} user_modified_val
*/
function meta_news_r() {
/*
CREATE OR REPLACE FUNCTION zzglc.meta_news_r()
RETURNS TABLE(id integer, name character varying, active boolean, time_modified timestamp with time zone, auth_person__user_modified_id integer, time_created timestamp with time zone, auth_person__user_modified_id_val character varying)
LANGUAGE plpgsql
AS $function$
BEGIN
RETURN QUERY
SELECT
t.id, t.name, t.active, t.time_modified, t.user_modified_id, t.time_created
, user_modified_t.name::VARCHAR AS user_modified_val
FROM meta.news t
LEFT JOIN auth.person user_modified_t ON user_modified_t.id = t.user_modified_id
ORDER BY t.time_modified DESC
;
END $function$
*/
}
/**
* @function meta_news_u
* @memberof zzglc
* @description Meta news u
* @param {character_varying} Json
* @returns {void}
*/
function meta_news_u() {
/*
CREATE OR REPLACE FUNCTION zzglc.meta_news_u("Json" character varying)
RETURNS void
LANGUAGE plpgsql
AS $function$
DECLARE v_row_count INTEGER;
BEGIN
UPDATE meta.news t
SET name = U.name,
active = U.active,
user_modified_id = auth.get_context_person_id()
FROM json_to_record("Json"::json) AS U (
id integer,
name character varying(255),
active boolean
)
WHERE t.id = U.id;
END $function$
*/
}
/**
* @function meta_route_c
* @memberof zzglc
* @description Meta route c
* @param {character_varying} Json
* @returns {integer}
*/
function meta_route_c() {
/*
CREATE OR REPLACE FUNCTION zzglc.meta_route_c("Json" character varying)
RETURNS integer
LANGUAGE plpgsql
AS $function$
DECLARE v_id integer;
DECLARE json_data json;
BEGIN
json_data := "Json";
INSERT INTO meta.route (name, order_no, path, component, icon, parent, props, offline, public, active, locked, title)
VALUES ((json_data->>'name')::character varying, (json_data->>'order_no')::integer, (json_data->>'path')::character varying, (json_data->>'component')::character varying, (json_data->>'icon')::character varying, (json_data->>'parent')::character varying, (json_data->>'props')::json, (json_data->>'offline')::boolean, (json_data->>'public')::boolean, (json_data->>'active')::boolean, (json_data->>'locked')::boolean, (json_data->>'title')::character varying)
RETURNING id INTO v_id;
RETURN v_id;
END $function$
*/
}
/**
* @function meta_route_d
* @memberof zzglc
* @description Meta route d
* @param {integer} Key
* @returns {void}
*/
function meta_route_d() {
/*
CREATE OR REPLACE FUNCTION zzglc.meta_route_d("Key" integer)
RETURNS void
LANGUAGE plpgsql
AS $function$
BEGIN
DELETE FROM meta.route WHERE id = "Key";
END;
$function$
*/
}
/**
* @function meta_route_r
* @memberof zzglc
* @description Meta route r
* @returns {Object} integer idcharacter_varying nameinteger order_nocharacter_varying pathcharacter_varying componentcharacter_varying iconcharacter_varying parentjson propsboolean offlineboolean publicboolean activeboolean lockedcharacter_varying title
*/
function meta_route_r() {
/*
CREATE OR REPLACE FUNCTION zzglc.meta_route_r()
RETURNS TABLE(id integer, name character varying, order_no integer, path character varying, component character varying, icon character varying, parent character varying, props json, offline boolean, public boolean, active boolean, locked boolean, title character varying)
LANGUAGE plpgsql
AS $function$
BEGIN
RETURN QUERY (
SELECT t.id, t.name, t.order_no, t.path, t.component, t.icon, t.parent, t.props, t.offline, t.public, t.active, t.locked, t.title
FROM meta.route t
ORDER BY 2
);
END $function$
*/
}
/**
* @function meta_route_u
* @memberof zzglc
* @description Meta route u
* @param {character_varying} Json
* @returns {void}
*/
function meta_route_u() {
/*
CREATE OR REPLACE FUNCTION zzglc.meta_route_u("Json" character varying)
RETURNS void
LANGUAGE plpgsql
AS $function$
DECLARE json_data json;
BEGIN
json_data := "Json";
UPDATE meta.route SET
name = (json_data->>'name')::character varying,
order_no = (json_data->>'order_no')::integer,
path = (json_data->>'path')::character varying,
component = (json_data->>'component')::character varying,
icon = (json_data->>'icon')::character varying,
parent = (json_data->>'parent')::character varying,
props = (json_data->>'props')::json,
offline = (json_data->>'offline')::boolean,
public = (json_data->>'public')::boolean,
active = (json_data->>'active')::boolean,
locked = (json_data->>'locked')::boolean,
title = (json_data->>'title')::character varying
WHERE id = (json_data->>'id')::integer;
END $function$
*/
}
/**
* @function meta_safe_function_c
* @memberof zzglc
* @description Meta safe function c
* @param {character_varying} Json
* @returns {void}
*/
function meta_safe_function_c() {
/*
CREATE OR REPLACE FUNCTION zzglc.meta_safe_function_c("Json" character varying)
RETURNS void
LANGUAGE plpgsql
AS $function$
BEGIN
INSERT INTO meta.safe_function (
name
)
SELECT
U.name
FROM
json_to_record("Json"::json) U (
name character varying(255)
)
;
END $function$
*/
}
/**
* @function meta_safe_function_d
* @memberof zzglc
* @description Meta safe function d
* @param {integer} Key
* @returns {void}
*/
function meta_safe_function_d() {
/*
CREATE OR REPLACE FUNCTION zzglc.meta_safe_function_d("Key" integer)
RETURNS void
LANGUAGE plpgsql
AS $function$
BEGIN
DELETE FROM meta.safe_function
WHERE id = "Key";
END $function$
*/
}
/**
* @function meta_safe_function_r
* @memberof zzglc
* @description Meta safe function r
* @returns {Object}
* @property {integer} id
* @property {character_varying} name
*/
function meta_safe_function_r() {
/*
CREATE OR REPLACE FUNCTION zzglc.meta_safe_function_r()
RETURNS TABLE(id integer, name character varying)
LANGUAGE plpgsql
AS $function$
BEGIN
RETURN QUERY
SELECT
t.id, t.name
FROM meta.safe_function t
ORDER BY 2
;
END $function$
*/
}
/**
* @function meta_safe_function_u
* @memberof zzglc
* @description Meta safe function u
* @param {character_varying} Json
* @returns {void}
*/
function meta_safe_function_u() {
/*
CREATE OR REPLACE FUNCTION zzglc.meta_safe_function_u("Json" character varying)
RETURNS void
LANGUAGE plpgsql
AS $function$
DECLARE v_row_count INTEGER;
BEGIN
UPDATE meta.safe_function t
SET name = U.name
FROM json_to_record("Json"::json) AS U (
id integer,
name character varying(255)
)
WHERE U.id = t.id
;
END $function$
*/
}
/**
* @function meta_table_ref_col_c
* @memberof zzglc
* @description Meta table ref col c
* @param {character_varying} Json
* @returns {integer}
*/
function meta_table_ref_col_c() {
/*
CREATE OR REPLACE FUNCTION zzglc.meta_table_ref_col_c("Json" character varying)
RETURNS integer
LANGUAGE plpgsql
AS $function$
DECLARE v_id integer;
DECLARE json_data json;
BEGIN
json_data := "Json";
INSERT INTO meta.table_ref_col (schema_name, table_name, ref_col)
VALUES ((json_data->>'schema_name')::character varying, (json_data->>'table_name')::character varying, (json_data->>'ref_col')::character varying)
RETURNING id INTO v_id;
RETURN v_id;
END $function$
*/
}
/**
* @function meta_table_ref_col_d
* @memberof zzglc
* @description Meta table ref col d
* @param {integer} Key
* @returns {void}
*/
function meta_table_ref_col_d() {
/*
CREATE OR REPLACE FUNCTION zzglc.meta_table_ref_col_d("Key" integer)
RETURNS void
LANGUAGE plpgsql
AS $function$
BEGIN
DELETE FROM meta.table_ref_col WHERE id = "Key";
END;
$function$
*/
}
/**
* @function meta_table_ref_col_r
* @memberof zzglc
* @description Meta table ref col r
* @returns {Object} integer idcharacter_varying schema_namecharacter_varying table_namecharacter_varying ref_col
*/
function meta_table_ref_col_r() {
/*
CREATE OR REPLACE FUNCTION zzglc.meta_table_ref_col_r()
RETURNS TABLE(id integer, schema_name character varying, table_name character varying, ref_col character varying)
LANGUAGE plpgsql
AS $function$
BEGIN
RETURN QUERY (
SELECT t.id, t.schema_name, t.table_name, t.ref_col
FROM meta.table_ref_col t
ORDER BY 2
);
END $function$
*/
}
/**
* @function meta_table_ref_col_u
* @memberof zzglc
* @description Meta table ref col u
* @param {character_varying} Json
* @returns {void}
*/
function meta_table_ref_col_u() {
/*
CREATE OR REPLACE FUNCTION zzglc.meta_table_ref_col_u("Json" character varying)
RETURNS void
LANGUAGE plpgsql
AS $function$
DECLARE json_data json;
BEGIN
json_data := "Json";
UPDATE meta.table_ref_col SET
schema_name = (json_data->>'schema_name')::character varying,
table_name = (json_data->>'table_name')::character varying,
ref_col = (json_data->>'ref_col')::character varying
WHERE id = (json_data->>'id')::integer;
END $function$
*/
}
/**
* @function meta_tableapi_props_c
* @memberof zzglc
* @description Meta tableapi props c
* @param {character_varying} Json
* @returns {integer}
*/
function meta_tableapi_props_c() {
/*
CREATE OR REPLACE FUNCTION zzglc.meta_tableapi_props_c("Json" character varying)
RETURNS integer
LANGUAGE plpgsql
AS $function$
DECLARE v_id integer;
DECLARE json_data json;
BEGIN
json_data := "Json";
INSERT INTO meta.tableapi_props (tableapi, props, colatts)
VALUES ((json_data->>'tableapi')::character varying, (json_data->>'props')::json, (json_data->>'colatts')::json)
RETURNING id INTO v_id;
RETURN v_id;
END $function$
*/
}
/**
* @function meta_tableapi_props_d
* @memberof zzglc
* @description Meta tableapi props d
* @param {integer} Key
* @returns {void}
*/
function meta_tableapi_props_d() {
/*
CREATE OR REPLACE FUNCTION zzglc.meta_tableapi_props_d("Key" integer)
RETURNS void
LANGUAGE plpgsql
AS $function$
BEGIN
DELETE FROM meta.tableapi_props WHERE id = "Key";
END;
$function$
*/
}
/**
* @function meta_tableapi_props_r
* @memberof zzglc
* @description Meta tableapi props r
* @returns {Object} integer idcharacter_varying tableapijson propsjson colatts
*/
function meta_tableapi_props_r() {
/*
CREATE OR REPLACE FUNCTION zzglc.meta_tableapi_props_r()
RETURNS TABLE(id integer, tableapi character varying, props json, colatts json)
LANGUAGE plpgsql
AS $function$
BEGIN
RETURN QUERY (
SELECT t.id, t.tableapi, t.props, t.colatts
FROM meta.tableapi_props t
ORDER BY 2
);
END $function$
*/
}
/**
* @function meta_tableapi_props_u
* @memberof zzglc
* @description Meta tableapi props u
* @param {character_varying} Json
* @returns {void}
*/
function meta_tableapi_props_u() {
/*
CREATE OR REPLACE FUNCTION zzglc.meta_tableapi_props_u("Json" character varying)
RETURNS void
LANGUAGE plpgsql
AS $function$
DECLARE json_data json;
BEGIN
json_data := "Json";
UPDATE meta.tableapi_props SET
tableapi = (json_data->>'tableapi')::character varying,
props = (json_data->>'props')::json,
colatts = (json_data->>'colatts')::json
WHERE id = (json_data->>'id')::integer;
END $function$
*/
}
/**
* @function meta_trace_c
* @memberof zzglc
* @description Meta trace c
* @param {character_varying} Json
* @returns {void}
*/
function meta_trace_c() {
/*
CREATE OR REPLACE FUNCTION zzglc.meta_trace_c("Json" character varying)
RETURNS void
LANGUAGE plpgsql
AS $function$
BEGIN
INSERT INTO meta.trace (
text
)
SELECT
U.text
FROM
json_to_record("Json"::json) U (
text character varying
)
;
END $function$
*/
}
/**
* @function meta_trace_d
* @memberof zzglc
* @description Meta trace d
* @param {integer} Key
* @returns {void}
*/
function meta_trace_d() {
/*
CREATE OR REPLACE FUNCTION zzglc.meta_trace_d("Key" integer)
RETURNS void
LANGUAGE plpgsql
AS $function$
BEGIN
DELETE FROM meta.trace
WHERE id = "Key";
END $function$
*/
}
/**
* @function meta_trace_r
* @memberof zzglc
* @description Meta trace r
* @returns {Object}
* @property {integer} id
* @property {character_varying} text
* @property {timestamp_without_time_zone} time_modified
*/
function meta_trace_r() {
/*
CREATE OR REPLACE FUNCTION zzglc.meta_trace_r()
RETURNS TABLE(id integer, text character varying, time_modified timestamp without time zone)
LANGUAGE plpgsql
AS $function$
BEGIN
RETURN QUERY
SELECT
t.id, t.text, t.time_modified
FROM meta.trace t
ORDER BY t.time_modified DESC
;
END $function$
*/
}
/**
* @function meta_trace_u
* @memberof zzglc
* @description Meta trace u
* @param {character_varying} Json
* @returns {void}
*/
function meta_trace_u() {
/*
CREATE OR REPLACE FUNCTION zzglc.meta_trace_u("Json" character varying)
RETURNS void
LANGUAGE plpgsql
AS $function$
DECLARE v_row_count INTEGER;
BEGIN
UPDATE meta.trace t
SET text = U.text
FROM json_to_record("Json"::json) AS U (
id integer,
text character varying(32768),
time_modified timestamp without time zone
)
WHERE U.id = t.id
AND t.time_modified = U.time_modified;
GET DIAGNOSTICS v_row_count = ROW_COUNT;
IF v_row_count = 0 THEN
SELECT meta.raise_error(2);
END IF
;
END $function$
*/
}
/**
* @function auth_person_l
* @memberof zzgll
* @description Auth person l
* @param {character_varying} SearchValue
* @param {integer} Key
* @returns {Object} integer idcharacter_varying name
*/
function auth_person_l() {
/*
CREATE OR REPLACE FUNCTION zzgll.auth_person_l("SearchValue" character varying, "Key" integer DEFAULT NULL::integer)
RETURNS TABLE(id integer, name character varying)
LANGUAGE plpgsql
AS $function$
BEGIN
IF "Key" IS NOT NULL THEN
RETURN QUERY
SELECT t.id, t.name
FROM auth.person t
WHERE t.id = "Key"::integer;
ELSE
RETURN QUERY
SELECT t.id, t.name
FROM auth.person t
WHERE t.name LIKE "SearchValue"
ORDER BY 2
LIMIT 1000;
END IF;
END $function$
*/
}
/**
* @function auth_role_l
* @memberof zzgll
* @description Auth role l
* @param {character_varying} SearchValue
* @param {integer} Key
* @returns {Object} integer idcharacter_varying name
*/
function auth_role_l() {
/*
CREATE OR REPLACE FUNCTION zzgll.auth_role_l("SearchValue" character varying, "Key" integer DEFAULT NULL::integer)
RETURNS TABLE(id integer, name character varying)
LANGUAGE plpgsql
AS $function$
BEGIN
IF "Key" IS NOT NULL THEN
RETURN QUERY
SELECT t.id, t.name
FROM auth.role t
WHERE t.id = "Key"::integer;
ELSE
RETURN QUERY
SELECT t.id, t.name
FROM auth.role t
WHERE t.name LIKE "SearchValue"
ORDER BY t.name
LIMIT 1000;
END IF;
END $function$
*/
}
/**
* @function catalog_accession_l
* @memberof zzgll
* @description Catalog accession l
* @param {character_varying} SearchValue
* @param {integer} Key
* @returns {Object} integer idcharacter_varying name
*/
function catalog_accession_l() {
/*
CREATE OR REPLACE FUNCTION zzgll.catalog_accession_l("SearchValue" character varying, "Key" integer DEFAULT NULL::integer)
RETURNS TABLE(id integer, name character varying)
LANGUAGE plpgsql
AS $function$
BEGIN
IF "Key" IS NOT NULL THEN
RETURN QUERY
SELECT t.id, t.name
FROM catalog.accession t
WHERE t.id = "Key"::integer;
ELSE
RETURN QUERY
SELECT t.id, t.name
FROM catalog.accession t
WHERE t.name LIKE "SearchValue"
ORDER BY t.name
LIMIT 1000;
END IF;
END $function$
*/
}
/**
* @function catalog_aggregate_stability_app_l
* @memberof zzgll
* @description Catalog aggregate stability app l
* @param {character_varying} SearchValue
* @param {integer} Key
* @returns {Object} integer idcharacter_varying name
*/
function catalog_aggregate_stability_app_l() {
/*
CREATE OR REPLACE FUNCTION zzgll.catalog_aggregate_stability_app_l("SearchValue" character varying, "Key" integer DEFAULT NULL::integer)
RETURNS TABLE(id integer, name character varying)
LANGUAGE plpgsql
AS $function$
BEGIN
IF "Key" IS NOT NULL THEN
RETURN QUERY
SELECT t.id, t.name
FROM catalog.aggregate_stability_app t
WHERE t.id = "Key"::integer;
ELSE
RETURN QUERY
SELECT t.id, t.name
FROM catalog.aggregate_stability_app t
WHERE t.name LIKE "SearchValue"
ORDER BY t.name
LIMIT 1000;
END IF;
END $function$
*/
}
/**
* @function catalog_amplification_l
* @memberof zzgll
* @description Catalog amplification l
* @param {character_varying} SearchValue
* @param {integer} Key
* @returns {Object} integer idcharacter_varying name
*/
function catalog_amplification_l() {
/*
CREATE OR REPLACE FUNCTION zzgll.catalog_amplification_l("SearchValue" character varying, "Key" integer DEFAULT NULL::integer)
RETURNS TABLE(id integer, name character varying)
LANGUAGE plpgsql
AS $function$
BEGIN
IF "Key" IS NOT NULL THEN
RETURN QUERY
SELECT t.id, t.name
FROM catalog.amplification t
WHERE t.id = "Key"::integer;
ELSE
RETURN QUERY
SELECT t.id, t.name
FROM catalog.amplification t
WHERE t.name LIKE "SearchValue"
ORDER BY t.name
LIMIT 1000;
END IF;
END $function$
*/
}
/**
* @function catalog_application_l
* @memberof zzgll
* @description Catalog application l
* @param {character_varying} SearchValue
* @param {integer} Key
* @returns {Object} integer idcharacter_varying name
*/
function catalog_application_l() {
/*
CREATE OR REPLACE FUNCTION zzgll.catalog_application_l("SearchValue" character varying, "Key" integer DEFAULT NULL::integer)
RETURNS TABLE(id integer, name character varying)
LANGUAGE plpgsql
AS $function$
BEGIN
IF "Key" IS NOT NULL THEN
RETURN QUERY
SELECT t.id, t.name
FROM catalog.application t
WHERE t.id = "Key"::integer;
ELSE
RETURN QUERY
SELECT t.id, t.name
FROM catalog.application t
WHERE t.name LIKE "SearchValue"
ORDER BY t.name
LIMIT 1000;
END IF;
END $function$
*/
}
/**
* @function catalog_asset_catalog_l
* @memberof zzgll
* @description Catalog asset catalog l
* @param {character_varying} SearchValue
* @param {integer} Key
* @returns {Object} integer idcharacter_varying name
*/
function catalog_asset_catalog_l() {
/*
CREATE OR REPLACE FUNCTION zzgll.catalog_asset_catalog_l("SearchValue" character varying, "Key" integer DEFAULT NULL::integer)
RETURNS TABLE(id integer, name character varying)
LANGUAGE plpgsql
AS $function$
BEGIN
IF "Key" IS NOT NULL THEN
RETURN QUERY
SELECT t.id, t.name
FROM catalog.asset_catalog t
WHERE t.id = "Key"::integer;
ELSE
RETURN QUERY
SELECT t.id, t.name
FROM catalog.asset_catalog t
WHERE t.name LIKE "SearchValue"
ORDER BY t.name
LIMIT 1000;
END IF;
END $function$
*/
}
/**
* @function catalog_asset_theme_l
* @memberof zzgll
* @description Catalog asset theme l
* @param {character_varying} SearchValue
* @param {integer} Key
* @returns {Object} integer idcharacter_varying name
*/
function catalog_asset_theme_l() {
/*
CREATE OR REPLACE FUNCTION zzgll.catalog_asset_theme_l("SearchValue" character varying, "Key" integer DEFAULT NULL::integer)
RETURNS TABLE(id integer, name character varying)
LANGUAGE plpgsql
AS $function$
BEGIN
IF "Key" IS NOT NULL THEN
RETURN QUERY
SELECT t.id, t.name
FROM catalog.asset_theme t
WHERE t.id = "Key"::integer;
ELSE
RETURN QUERY
SELECT t.id, t.name
FROM catalog.asset_theme t
WHERE t.name LIKE "SearchValue"
ORDER BY t.name
LIMIT 1000;
END IF;
END $function$
*/
}
/**
* @function catalog_asset_version_l
* @memberof zzgll
* @description Data asset version l
* @param {character_varying} SearchValue
* @param {integer} Key
* @returns {Object}
* @property {integer} id
* @property {character_varying} name
*/
function catalog_asset_version_l() {
/*
CREATE OR REPLACE FUNCTION zzgll.catalog_asset_version_l("SearchValue" character varying, "Key" integer DEFAULT NULL::integer)
RETURNS TABLE(id integer, name character varying)
LANGUAGE plpgsql
AS $function$
BEGIN
IF "Key" IS NOT NULL THEN
RETURN QUERY
SELECT t.id, t.name
FROM catalog.asset_version t
WHERE t.id = "Key"::integer;
ELSE
RETURN QUERY
SELECT t.id, t.name
FROM catalog.asset_version t
WHERE t.name LIKE "SearchValue"
ORDER BY t.name
LIMIT 1000;
END IF;
END $function$
*/
}
/**
* @function catalog_brand_l
* @memberof zzgll
* @description Catalog brand l
* @param {character_varying} SearchValue
* @param {integer} Key
* @returns {Object} integer idcharacter_varying name
*/
function catalog_brand_l() {
/*
CREATE OR REPLACE FUNCTION zzgll.catalog_brand_l("SearchValue" character varying, "Key" integer DEFAULT NULL::integer)
RETURNS TABLE(id integer, name character varying)
LANGUAGE plpgsql
AS $function$
BEGIN
IF "Key" IS NOT NULL THEN
RETURN QUERY
SELECT t.id, t.name
FROM catalog.brand t
WHERE t.id = "Key"::int;
ELSE
RETURN QUERY
SELECT t.id, t.name
FROM catalog.brand t
WHERE t.name LIKE "SearchValue"
ORDER BY t.name
LIMIT 1000;
END IF;
END $function$
*/
}
/**
* @function catalog_crop_growth_stage_l
* @memberof zzgll
* @description Catalog crop growth stage l
* @param {character_varying} SearchValue
* @param {integer} Key
* @returns {Object} integer idcharacter_varying name
*/
function catalog_crop_growth_stage_l() {
/*
CREATE OR REPLACE FUNCTION zzgll.catalog_crop_growth_stage_l("SearchValue" character varying, "Key" integer DEFAULT NULL::integer)
RETURNS TABLE(id integer, name character varying)
LANGUAGE plpgsql
AS $function$
BEGIN
IF "Key" IS NOT NULL THEN
RETURN QUERY
SELECT t.id, t.name
FROM catalog.crop_growth_stage t
WHERE t.id = "Key"::integer;
ELSE
RETURN QUERY
SELECT t.id, t.name
FROM catalog.crop_growth_stage t
WHERE t.name LIKE "SearchValue"
ORDER BY t.name
LIMIT 1000;
END IF;
END $function$
*/
}
/**
* @function catalog_crop_l
* @memberof zzgll
* @description Catalog crop l
* @param {character_varying} SearchValue
* @param {integer} Key
* @returns {Object} integer idcharacter_varying name
*/
function catalog_crop_l() {
/*
CREATE OR REPLACE FUNCTION zzgll.catalog_crop_l("SearchValue" character varying, "Key" integer DEFAULT NULL::integer)
RETURNS TABLE(id integer, name character varying)
LANGUAGE plpgsql
AS $function$
BEGIN
IF "Key" IS NOT NULL THEN
RETURN QUERY
SELECT t.id, t.name
FROM catalog.crop t
WHERE t.id = "Key"::integer;
ELSE
RETURN QUERY
SELECT t.id, t.name
FROM catalog.crop t
WHERE t.name LIKE "SearchValue"
ORDER BY t.name
LIMIT 1000;
END IF;
END $function$
*/
}
/**
* @function catalog_date_style_l
* @memberof zzgll
* @description Catalog date style l
* @param {character_varying} SearchValue
* @param {integer} Key
* @returns {Object} integer idcharacter_varying name
*/
function catalog_date_style_l() {
/*
CREATE OR REPLACE FUNCTION zzgll.catalog_date_style_l("SearchValue" character varying, "Key" integer DEFAULT NULL::integer)
RETURNS TABLE(id integer, name character varying)
LANGUAGE plpgsql
AS $function$
BEGIN
IF "Key" IS NOT NULL THEN
RETURN QUERY
SELECT t.id, t.name
FROM catalog.date_style t
WHERE t.id = "Key"::integer;
ELSE
RETURN QUERY
SELECT t.id, t.name
FROM catalog.date_style t
WHERE t.name LIKE "SearchValue"
ORDER BY t.name
LIMIT 1000;
END IF;
END $function$
*/
}
/**
* @function catalog_date_unit_l
* @memberof zzgll
* @description Catalog date unit l
* @param {character_varying} SearchValue
* @param {integer} Key
* @returns {Object} integer idcharacter_varying name
*/
function catalog_date_unit_l() {
/*
CREATE OR REPLACE FUNCTION zzgll.catalog_date_unit_l("SearchValue" character varying, "Key" integer DEFAULT NULL::integer)
RETURNS TABLE(id integer, name character varying)
LANGUAGE plpgsql
AS $function$
BEGIN
IF "Key" IS NOT NULL THEN
RETURN QUERY
SELECT t.id, t.name
FROM catalog.date_unit t
WHERE t.id = "Key"::integer;
ELSE
RETURN QUERY
SELECT t.id, t.name
FROM catalog.date_unit t
WHERE t.name LIKE "SearchValue"
ORDER BY t.name
LIMIT 1000;
END IF;
END $function$
*/
}
/**
* @function catalog_direction_l
* @memberof zzgll
* @description Catalog direction l
* @param {character_varying} SearchValue
* @param {integer} Key
* @returns {Object} integer idcharacter_varying name
*/
function catalog_direction_l() {
/*
CREATE OR REPLACE FUNCTION zzgll.catalog_direction_l("SearchValue" character varying, "Key" integer DEFAULT NULL::integer)
RETURNS TABLE(id integer, name character varying)
LANGUAGE plpgsql
AS $function$
BEGIN
IF "Key" IS NOT NULL THEN
RETURN QUERY
SELECT t.id, t.name
FROM catalog.direction t
WHERE t.id = "Key"::integer;
ELSE
RETURN QUERY
SELECT t.id, t.name
FROM catalog.direction t
WHERE t.name LIKE "SearchValue"
ORDER BY t.name
LIMIT 1000;
END IF;
END $function$
*/
}
/**
* @function catalog_environmental_zone_l
* @memberof zzgll
* @description Catalog environmental zone l
* @param {character_varying} SearchValue
* @param {integer} Key
* @returns {Object} integer idcharacter_varying name
*/
function catalog_environmental_zone_l() {
/*
CREATE OR REPLACE FUNCTION zzgll.catalog_environmental_zone_l("SearchValue" character varying, "Key" integer DEFAULT NULL::integer)
RETURNS TABLE(id integer, name character varying)
LANGUAGE plpgsql
AS $function$
BEGIN
IF "Key" IS NOT NULL THEN
RETURN QUERY
SELECT t.id, t.name
FROM catalog.environmental_zone t
WHERE t.id = "Key"::integer;
ELSE
RETURN QUERY
SELECT t.id, t.name
FROM catalog.environmental_zone t
WHERE t.name LIKE "SearchValue"
ORDER BY t.name
LIMIT 1000;
END IF;
END $function$
*/
}
/**
* @function catalog_enzyme_type_l
* @memberof zzgll
* @description Catalog enzyme type l
* @param {character_varying} SearchValue
* @param {integer} Key
* @returns {Object} integer idcharacter_varying name
*/
function catalog_enzyme_type_l() {
/*
CREATE OR REPLACE FUNCTION zzgll.catalog_enzyme_type_l("SearchValue" character varying, "Key" integer DEFAULT NULL::integer)
RETURNS TABLE(id integer, name character varying)
LANGUAGE plpgsql
AS $function$
BEGIN
IF "Key" IS NOT NULL THEN
RETURN QUERY
SELECT t.id, t.name
FROM catalog.enzyme_type t
WHERE t.id = "Key"::integer;
ELSE
RETURN QUERY
SELECT t.id, t.name
FROM catalog.enzyme_type t
WHERE t.name LIKE "SearchValue"
ORDER BY t.name
LIMIT 1000;
END IF;
END $function$
*/
}
/**
* @function catalog_equipment_type_l
* @memberof zzgll
* @description Catalog equipment type l
* @param {character_varying} SearchValue
* @param {integer} Key
* @returns {Object} integer idcharacter_varying name
*/
function catalog_equipment_type_l() {
/*
CREATE OR REPLACE FUNCTION zzgll.catalog_equipment_type_l("SearchValue" character varying, "Key" integer DEFAULT NULL::integer)
RETURNS TABLE(id integer, name character varying)
LANGUAGE plpgsql
AS $function$
BEGIN
IF "Key" IS NOT NULL THEN
RETURN QUERY
SELECT t.id, t.name
FROM catalog.equipment_type t
WHERE t.id = "Key"::integer;
ELSE
RETURN QUERY
SELECT t.id, t.name
FROM catalog.equipment_type t
WHERE t.name LIKE "SearchValue"
ORDER BY t.name
LIMIT 1000;
END IF;
END $function$
*/
}
/**
* @function catalog_erosion_conservation_measure_l
* @memberof zzgll
* @description Catalog erosion conservation measure l
* @param {character_varying} SearchValue
* @param {integer} Key
* @returns {Object} integer idcharacter_varying name
*/
function catalog_erosion_conservation_measure_l() {
/*
CREATE OR REPLACE FUNCTION zzgll.catalog_erosion_conservation_measure_l("SearchValue" character varying, "Key" integer DEFAULT NULL::integer)
RETURNS TABLE(id integer, name character varying)
LANGUAGE plpgsql
AS $function$
BEGIN
IF "Key" IS NOT NULL THEN
RETURN QUERY
SELECT t.id, t.name
FROM catalog.erosion_conservation_measure t
WHERE t.id = "Key"::integer;
ELSE
RETURN QUERY
SELECT t.id, t.name
FROM catalog.erosion_conservation_measure t
WHERE t.name LIKE "SearchValue"
ORDER BY t.name
LIMIT 1000;
END IF;
END $function$
*/
}
/**
* @function catalog_extraction_l
* @memberof zzgll
* @description Catalog extraction l
* @param {character_varying} SearchValue
* @param {integer} Key
* @returns {Object} integer idcharacter_varying name
*/
function catalog_extraction_l() {
/*
CREATE OR REPLACE FUNCTION zzgll.catalog_extraction_l("SearchValue" character varying, "Key" integer DEFAULT NULL::integer)
RETURNS TABLE(id integer, name character varying)
LANGUAGE plpgsql
AS $function$
BEGIN
IF "Key" IS NOT NULL THEN
RETURN QUERY
SELECT t.id, t.name
FROM catalog.extraction t
WHERE t.id = "Key"::integer;
ELSE
RETURN QUERY
SELECT t.id, t.name
FROM catalog.extraction t
WHERE t.name LIKE "SearchValue"
ORDER BY t.name
LIMIT 1000;
END IF;
END $function$
*/
}
/**
* @function catalog_extraction_method_l
* @memberof zzgll
* @description Catalog extraction method l
* @param {character_varying} SearchValue
* @param {integer} Key
* @returns {Object} integer idcharacter_varying name
*/
function catalog_extraction_method_l() {
/*
CREATE OR REPLACE FUNCTION zzgll.catalog_extraction_method_l("SearchValue" character varying, "Key" integer DEFAULT NULL::integer)
RETURNS TABLE(id integer, name character varying)
LANGUAGE plpgsql
AS $function$
BEGIN
IF "Key" IS NOT NULL THEN
RETURN QUERY
SELECT t.id, t.name
FROM catalog.extraction_method t
WHERE t.id = "Key"::integer;
ELSE
RETURN QUERY
SELECT t.id, t.name
FROM catalog.extraction_method t
WHERE t.name LIKE "SearchValue"
ORDER BY t.name
LIMIT 1000;
END IF;
END $function$
*/
}
/**
* @function catalog_fao_standard_l
* @memberof zzgll
* @description Catalog fao standard l
* @param {character_varying} SearchValue
* @param {integer} Key
* @returns {Object} integer idtext name
*/
function catalog_fao_standard_l() {
/*
CREATE OR REPLACE FUNCTION zzgll.catalog_fao_standard_l("SearchValue" character varying, "Key" integer DEFAULT NULL::integer)
RETURNS TABLE(id integer, name text)
LANGUAGE plpgsql
AS $function$
BEGIN
IF "Key" IS NOT NULL THEN
RETURN QUERY
SELECT t.id, t.name::text || ' (' || t.version::text || ')' name
FROM catalog.fao_standard t
WHERE t.id = "Key"::integer;
ELSE
RETURN QUERY
SELECT t.id, t.name::text || ' (' || t.version::text || ')' name
FROM catalog.fao_standard t
WHERE t.name LIKE "SearchValue"
ORDER BY t.name
LIMIT 1000;
END IF;
END $function$
*/
}
/**
* @function catalog_ground_condition_l
* @memberof zzgll
* @description Catalog ground condition l
* @param {character_varying} SearchValue
* @param {integer} Key
* @returns {Object} integer idcharacter_varying name
*/
function catalog_ground_condition_l() {
/*
CREATE OR REPLACE FUNCTION zzgll.catalog_ground_condition_l("SearchValue" character varying, "Key" integer DEFAULT NULL::integer)
RETURNS TABLE(id integer, name character varying)
LANGUAGE plpgsql
AS $function$
BEGIN
IF "Key" IS NOT NULL THEN
RETURN QUERY
SELECT t.id, t.name
FROM catalog.ground_condition t
WHERE t.id = "Key"::integer;
ELSE
RETURN QUERY
SELECT t.id, t.name
FROM catalog.ground_condition t
WHERE t.name LIKE "SearchValue"
ORDER BY t.name
LIMIT 1000;
END IF;
END $function$
*/
}
/**
* @function catalog_hillslope_position_l
* @memberof zzgll
* @description Catalog hillslope position l
* @param {character_varying} SearchValue
* @param {integer} Key
* @returns {Object} integer idcharacter_varying name
*/
function catalog_hillslope_position_l() {
/*
CREATE OR REPLACE FUNCTION zzgll.catalog_hillslope_position_l("SearchValue" character varying, "Key" integer DEFAULT NULL::integer)
RETURNS TABLE(id integer, name character varying)
LANGUAGE plpgsql
AS $function$
BEGIN
IF "Key" IS NOT NULL THEN
RETURN QUERY
SELECT t.id, t.name
FROM catalog.hillslope_position t
WHERE t.id = "Key"::integer;
ELSE
RETURN QUERY
SELECT t.id, t.name
FROM catalog.hillslope_position t
WHERE t.name LIKE "SearchValue"
ORDER BY t.name
LIMIT 1000;
END IF;
END $function$
*/
}
/**
* @function catalog_image_approach_l
* @memberof zzgll
* @description Catalog image approach l
* @param {character_varying} SearchValue
* @param {integer} Key
* @returns {Object} integer idcharacter_varying name
*/
function catalog_image_approach_l() {
/*
CREATE OR REPLACE FUNCTION zzgll.catalog_image_approach_l("SearchValue" character varying, "Key" integer DEFAULT NULL::integer)
RETURNS TABLE(id integer, name character varying)
LANGUAGE plpgsql
AS $function$
BEGIN
IF "Key" IS NOT NULL THEN
RETURN QUERY
SELECT t.id, t.name
FROM catalog.image_approach t
WHERE t.id = "Key"::integer;
ELSE
RETURN QUERY
SELECT t.id, t.name
FROM catalog.image_approach t
WHERE t.name LIKE "SearchValue"
ORDER BY t.name
LIMIT 1000;
END IF;
END $function$
*/
}
/**
* @function catalog_image_camera_l
* @memberof zzgll
* @description Catalog image camera l
* @param {character_varying} SearchValue
* @param {integer} Key
* @returns {Object} integer idcharacter_varying name
*/
function catalog_image_camera_l() {
/*
CREATE OR REPLACE FUNCTION zzgll.catalog_image_camera_l("SearchValue" character varying, "Key" integer DEFAULT NULL::integer)
RETURNS TABLE(id integer, name character varying)
LANGUAGE plpgsql
AS $function$
BEGIN
IF "Key" IS NOT NULL THEN
RETURN QUERY
SELECT t.id, t.name
FROM catalog.image_camera t
WHERE t.id = "Key"::integer;
ELSE
RETURN QUERY
SELECT t.id, t.name
FROM catalog.image_camera t
WHERE t.name LIKE "SearchValue"
ORDER BY t.name
LIMIT 1000;
END IF;
END $function$
*/
}
/**
* @function catalog_image_lightsource_l
* @memberof zzgll
* @description Catalog image lightsource l
* @param {character_varying} SearchValue
* @param {integer} Key
* @returns {Object} integer idcharacter_varying name
*/
function catalog_image_lightsource_l() {
/*
CREATE OR REPLACE FUNCTION zzgll.catalog_image_lightsource_l("SearchValue" character varying, "Key" integer DEFAULT NULL::integer)
RETURNS TABLE(id integer, name character varying)
LANGUAGE plpgsql
AS $function$
BEGIN
IF "Key" IS NOT NULL THEN
RETURN QUERY
SELECT t.id, t.name
FROM catalog.image_lightsource t
WHERE t.id = "Key"::integer;
ELSE
RETURN QUERY
SELECT t.id, t.name
FROM catalog.image_lightsource t
WHERE t.name LIKE "SearchValue"
ORDER BY t.name
LIMIT 1000;
END IF;
END $function$
*/
}
/**
* @function catalog_image_setup_l
* @memberof zzgll
* @description Catalog image setup l
* @param {character_varying} SearchValue
* @param {integer} Key
* @returns {Object} integer idcharacter_varying name
*/
function catalog_image_setup_l() {
/*
CREATE OR REPLACE FUNCTION zzgll.catalog_image_setup_l("SearchValue" character varying, "Key" integer DEFAULT NULL::integer)
RETURNS TABLE(id integer, name character varying)
LANGUAGE plpgsql
AS $function$
BEGIN
IF "Key" IS NOT NULL THEN
RETURN QUERY
SELECT t.id, t.name
FROM catalog.image_setup t
WHERE t.id = "Key"::integer;
ELSE
RETURN QUERY
SELECT t.id, t.name
FROM catalog.image_setup t
WHERE t.name LIKE "SearchValue"
ORDER BY t.name
LIMIT 1000;
END IF;
END $function$
*/
}
/**
* @function catalog_image_substrate_l
* @memberof zzgll
* @description Catalog image substrate l
* @param {character_varying} SearchValue
* @param {integer} Key
* @returns {Object} integer idcharacter_varying name
*/
function catalog_image_substrate_l() {
/*
CREATE OR REPLACE FUNCTION zzgll.catalog_image_substrate_l("SearchValue" character varying, "Key" integer DEFAULT NULL::integer)
RETURNS TABLE(id integer, name character varying)
LANGUAGE plpgsql
AS $function$
BEGIN
IF "Key" IS NOT NULL THEN
RETURN QUERY
SELECT t.id, t.name
FROM catalog.image_substrate t
WHERE t.id = "Key"::integer;
ELSE
RETURN QUERY
SELECT t.id, t.name
FROM catalog.image_substrate t
WHERE t.name LIKE "SearchValue"
ORDER BY t.name
LIMIT 1000;
END IF;
END $function$
*/
}
/**
* @function catalog_layer_l
* @memberof zzgll
* @description Catalog layer l
* @param {character_varying} SearchValue
* @param {integer} Key
* @returns {Object} integer idcharacter_varying name
*/
function catalog_layer_l() {
/*
CREATE OR REPLACE FUNCTION zzgll.catalog_layer_l("SearchValue" character varying, "Key" integer DEFAULT NULL::integer)
RETURNS TABLE(id integer, name character varying)
LANGUAGE plpgsql
AS $function$
BEGIN
IF "Key" IS NOT NULL THEN
RETURN QUERY
SELECT t.id, t.name
FROM catalog.layer t
WHERE t.id = "Key"::integer;
ELSE
RETURN QUERY
SELECT t.id, t.name
FROM catalog.layer t
WHERE t.name LIKE "SearchValue"
ORDER BY t.name
LIMIT 1000;
END IF;
END $function$
*/
}
/**
* @function catalog_license_l
* @memberof zzgll
* @description Catalog license l
* @param {character_varying} SearchValue
* @param {integer} Key
* @returns {Object} integer idcharacter_varying name
*/
function catalog_license_l() {
/*
CREATE OR REPLACE FUNCTION zzgll.catalog_license_l("SearchValue" character varying, "Key" integer DEFAULT NULL::integer)
RETURNS TABLE(id integer, name character varying)
LANGUAGE plpgsql
AS $function$
BEGIN
IF "Key" IS NOT NULL THEN
RETURN QUERY
SELECT t.id, t.name
FROM catalog.license t
WHERE t.id = "Key"::integer;
ELSE
RETURN QUERY
SELECT t.id, t.name
FROM catalog.license t
WHERE t.name LIKE "SearchValue"
ORDER BY t.name
LIMIT 1000;
END IF;
END $function$
*/
}
/**
* @function catalog_life_cycle_stage_l
* @memberof zzgll
* @description Catalog life cycle stage l
* @param {character_varying} SearchValue
* @param {integer} Key
* @returns {Object} integer idcharacter_varying name
*/
function catalog_life_cycle_stage_l() {
/*
CREATE OR REPLACE FUNCTION zzgll.catalog_life_cycle_stage_l("SearchValue" character varying, "Key" integer DEFAULT NULL::integer)
RETURNS TABLE(id integer, name character varying)
LANGUAGE plpgsql
AS $function$
BEGIN
IF "Key" IS NOT NULL THEN
RETURN QUERY
SELECT t.id, t.name
FROM catalog.life_cycle_stage t
WHERE t.id = "Key"::integer;
ELSE
RETURN QUERY
SELECT t.id, t.name
FROM catalog.life_cycle_stage t
WHERE t.name LIKE "SearchValue"
ORDER BY t.name
LIMIT 1000;
END IF;
END $function$
*/
}
/**
* @function catalog_macrofauna_excavation_tool_l
* @memberof zzgll
* @description Catalog macrofauna excavation tool l
* @param {character_varying} SearchValue
* @param {integer} Key
* @returns {Object} integer idcharacter_varying name
*/
function catalog_macrofauna_excavation_tool_l() {
/*
CREATE OR REPLACE FUNCTION zzgll.catalog_macrofauna_excavation_tool_l("SearchValue" character varying, "Key" integer DEFAULT NULL::integer)
RETURNS TABLE(id integer, name character varying)
LANGUAGE plpgsql
AS $function$
BEGIN
IF "Key" IS NOT NULL THEN
RETURN QUERY
SELECT t.id, t.name
FROM catalog.macrofauna_excavation_tool t
WHERE t.id = "Key"::integer;
ELSE
RETURN QUERY
SELECT t.id, t.name
FROM catalog.macrofauna_excavation_tool t
WHERE t.name LIKE "SearchValue"
ORDER BY t.name
LIMIT 1000;
END IF;
END $function$
*/
}
/**
* @function catalog_major_landform_l
* @memberof zzgll
* @description Catalog major landform l
* @param {character_varying} SearchValue
* @param {integer} Key
* @returns {Object} integer idcharacter_varying name
*/
function catalog_major_landform_l() {
/*
CREATE OR REPLACE FUNCTION zzgll.catalog_major_landform_l("SearchValue" character varying, "Key" integer DEFAULT NULL::integer)
RETURNS TABLE(id integer, name character varying)
LANGUAGE plpgsql
AS $function$
BEGIN
IF "Key" IS NOT NULL THEN
RETURN QUERY
SELECT t.id, t.name
FROM catalog.major_landform t
WHERE t.id = "Key"::integer;
ELSE
RETURN QUERY
SELECT t.id, t.name
FROM catalog.major_landform t
WHERE t.name LIKE "SearchValue"
ORDER BY t.name
LIMIT 1000;
END IF;
END $function$
*/
}
/**
* @function catalog_monolith_l
* @memberof zzgll
* @description Catalog monolith l
* @param {character_varying} SearchValue
* @param {integer} Key
* @returns {Object} integer idcharacter_varying name
*/
function catalog_monolith_l() {
/*
CREATE OR REPLACE FUNCTION zzgll.catalog_monolith_l("SearchValue" character varying, "Key" integer DEFAULT NULL::integer)
RETURNS TABLE(id integer, name character varying)
LANGUAGE plpgsql
AS $function$
BEGIN
IF "Key" IS NOT NULL THEN
RETURN QUERY
SELECT t.id, t.name
FROM catalog.monolith t
WHERE t.id = "Key"::integer;
ELSE
RETURN QUERY
SELECT t.id, t.name
FROM catalog.monolith t
WHERE t.name LIKE "SearchValue"
ORDER BY t.name
LIMIT 1000;
END IF;
END $function$
*/
}
/**
* @function catalog_observation_type_l
* @memberof zzgll
* @description Catalog observation type l
* @param {character_varying} SearchValue
* @param {integer} Key
* @returns {Object} integer idcharacter_varying name
*/
function catalog_observation_type_l() {
/*
CREATE OR REPLACE FUNCTION zzgll.catalog_observation_type_l("SearchValue" character varying, "Key" integer DEFAULT NULL::integer)
RETURNS TABLE(id integer, name character varying)
LANGUAGE plpgsql
AS $function$
BEGIN
IF "Key" IS NOT NULL THEN
RETURN QUERY
SELECT t.id, t.name
FROM catalog.observation_type t
WHERE t.id = "Key"::integer;
ELSE
RETURN QUERY
SELECT t.id, t.name
FROM catalog.observation_type t
WHERE t.name LIKE "SearchValue"
ORDER BY t.name
LIMIT 1000;
END IF;
END $function$
*/
}
/**
* @function catalog_preservation_l
* @memberof zzgll
* @description Catalog preservation l
* @param {character_varying} SearchValue
* @param {integer} Key
* @returns {Object} integer idcharacter_varying name
*/
function catalog_preservation_l() {
/*
CREATE OR REPLACE FUNCTION zzgll.catalog_preservation_l("SearchValue" character varying, "Key" integer DEFAULT NULL::integer)
RETURNS TABLE(id integer, name character varying)
LANGUAGE plpgsql
AS $function$
BEGIN
IF "Key" IS NOT NULL THEN
RETURN QUERY
SELECT t.id, t.name
FROM catalog.preservation t
WHERE t.id = "Key"::integer;
ELSE
RETURN QUERY
SELECT t.id, t.name
FROM catalog.preservation t
WHERE t.name LIKE "SearchValue"
ORDER BY t.name
LIMIT 1000;
END IF;
END $function$
*/
}
/**
* @function catalog_proprietor_l
* @memberof zzgll
* @description Catalog proprietor l
* @param {character_varying} SearchValue
* @param {integer} Key
* @returns {Object} integer idcharacter_varying name
*/
function catalog_proprietor_l() {
/*
CREATE OR REPLACE FUNCTION zzgll.catalog_proprietor_l("SearchValue" character varying, "Key" integer DEFAULT NULL::integer)
RETURNS TABLE(id integer, name character varying)
LANGUAGE plpgsql
AS $function$
BEGIN
IF "Key" IS NOT NULL THEN
RETURN QUERY
SELECT t.id, t.name
FROM catalog.proprietor t
WHERE t.id = "Key"::integer;
ELSE
RETURN QUERY
SELECT t.id, t.name
FROM catalog.proprietor t
WHERE t.name LIKE "SearchValue"
ORDER BY t.name
LIMIT 1000;
END IF;
END $function$
*/
}
/**
* @function catalog_purification_l
* @memberof zzgll
* @description Catalog purification l
* @param {character_varying} SearchValue
* @param {integer} Key
* @returns {Object} integer idcharacter_varying name
*/
function catalog_purification_l() {
/*
CREATE OR REPLACE FUNCTION zzgll.catalog_purification_l("SearchValue" character varying, "Key" integer DEFAULT NULL::integer)
RETURNS TABLE(id integer, name character varying)
LANGUAGE plpgsql
AS $function$
BEGIN
IF "Key" IS NOT NULL THEN
RETURN QUERY
SELECT t.id, t.name
FROM catalog.purification t
WHERE t.id = "Key"::integer;
ELSE
RETURN QUERY
SELECT t.id, t.name
FROM catalog.purification t
WHERE t.name LIKE "SearchValue"
ORDER BY t.name
LIMIT 1000;
END IF;
END $function$
*/
}
/**
* @function catalog_sample_preparation_l
* @memberof zzgll
* @description Catalog sample preparation l
* @param {character_varying} SearchValue
* @param {integer} Key
* @returns {Object} integer idcharacter_varying name
*/
function catalog_sample_preparation_l() {
/*
CREATE OR REPLACE FUNCTION zzgll.catalog_sample_preparation_l("SearchValue" character varying, "Key" integer DEFAULT NULL::integer)
RETURNS TABLE(id integer, name character varying)
LANGUAGE plpgsql
AS $function$
BEGIN
IF "Key" IS NOT NULL THEN
RETURN QUERY
SELECT t.id, t.name
FROM catalog.sample_preparation t
WHERE t.id = "Key"::integer;
ELSE
RETURN QUERY
SELECT t.id, t.name
FROM catalog.sample_preparation t
WHERE t.name LIKE "SearchValue"
ORDER BY t.name
LIMIT 1000;
END IF;
END $function$
*/
}
/**
* @function catalog_sample_type_l
* @memberof zzgll
* @description Catalog sample type l
* @param {character_varying} SearchValue
* @param {integer} Key
* @returns {Object} integer idcharacter_varying name
*/
function catalog_sample_type_l() {
/*
CREATE OR REPLACE FUNCTION zzgll.catalog_sample_type_l("SearchValue" character varying, "Key" integer DEFAULT NULL::integer)
RETURNS TABLE(id integer, name character varying)
LANGUAGE plpgsql
AS $function$
BEGIN
IF "Key" IS NOT NULL THEN
RETURN QUERY
SELECT t.id, t.name
FROM catalog.sample_type t
WHERE t.id = "Key"::integer;
ELSE
RETURN QUERY
SELECT t.id, t.name
FROM catalog.sample_type t
WHERE t.name LIKE "SearchValue"
ORDER BY t.name
LIMIT 1000;
END IF;
END $function$
*/
}
/**
* @function catalog_sequence_reference_library_l
* @memberof zzgll
* @description Catalog sequence reference library l
* @param {character_varying} SearchValue
* @param {integer} Key
* @returns {Object} integer idcharacter_varying name
*/
function catalog_sequence_reference_library_l() {
/*
CREATE OR REPLACE FUNCTION zzgll.catalog_sequence_reference_library_l("SearchValue" character varying, "Key" integer DEFAULT NULL::integer)
RETURNS TABLE(id integer, name character varying)
LANGUAGE plpgsql
AS $function$
BEGIN
IF "Key" IS NOT NULL THEN
RETURN QUERY
SELECT t.id, t.name
FROM catalog.sequence_reference_library t
WHERE t.id = "Key"::integer;
ELSE
RETURN QUERY
SELECT t.id, t.name
FROM catalog.sequence_reference_library t
WHERE t.name LIKE "SearchValue"
ORDER BY t.name
LIMIT 1000;
END IF;
END $function$
*/
}
/**
* @function catalog_sequencing_l
* @memberof zzgll
* @description Catalog sequencing l
* @param {character_varying} SearchValue
* @param {integer} Key
* @returns {Object} integer idcharacter_varying name
*/
function catalog_sequencing_l() {
/*
CREATE OR REPLACE FUNCTION zzgll.catalog_sequencing_l("SearchValue" character varying, "Key" integer DEFAULT NULL::integer)
RETURNS TABLE(id integer, name character varying)
LANGUAGE plpgsql
AS $function$
BEGIN
IF "Key" IS NOT NULL THEN
RETURN QUERY
SELECT t.id, t.name
FROM catalog.sequencing t
WHERE t.id = "Key"::integer;
ELSE
RETURN QUERY
SELECT t.id, t.name
FROM catalog.sequencing t
WHERE t.name LIKE "SearchValue"
ORDER BY t.name
LIMIT 1000;
END IF;
END $function$
*/
}
/**
* @function catalog_simple_observation_l
* @memberof zzgll
* @description Catalog simple observation l
* @param {character_varying} SearchValue
* @param {integer} Key
* @returns {Object} integer idcharacter_varying nameboolean numericalinteger decimals_for_displayreal value_fromreal value_tocharacter_varying unit
*/
function catalog_simple_observation_l() {
/*
CREATE OR REPLACE FUNCTION zzgll.catalog_simple_observation_l("SearchValue" character varying, "Key" integer DEFAULT NULL::integer)
RETURNS TABLE(id integer, name character varying, numerical boolean, decimals_for_display integer, value_from real, value_to real, unit character varying)
LANGUAGE plpgsql
AS $function$
BEGIN
IF "Key" IS NOT NULL THEN
RETURN QUERY
SELECT t.id, t.display_name, t.numerical, t.decimals_for_display, t.value_from, t.value_to, u.name
FROM data.indicator t
LEFT JOIN catalog.unit u ON t.unit_id = u.id
WHERE t.id = "Key"::integer;
ELSE
RETURN QUERY
SELECT t.id, t.display_name, t.numerical, t.decimals_for_display, t.value_from, t.value_to, u.name
FROM data.indicator t
LEFT JOIN catalog.unit u ON t.unit_id = u.id
WHERE t.name LIKE "SearchValue" AND t.simple_observation = true
ORDER BY t.name
LIMIT 1000;
END IF;
END $function$
*/
}
/**
* @function catalog_sky_condition_l
* @memberof zzgll
* @description Catalog sky condition l
* @param {character_varying} SearchValue
* @param {integer} Key
* @returns {Object} integer idcharacter_varying name
*/
function catalog_sky_condition_l() {
/*
CREATE OR REPLACE FUNCTION zzgll.catalog_sky_condition_l("SearchValue" character varying, "Key" integer DEFAULT NULL::integer)
RETURNS TABLE(id integer, name character varying)
LANGUAGE plpgsql
AS $function$
BEGIN
IF "Key" IS NOT NULL THEN
RETURN QUERY
SELECT t.id, t.name
FROM catalog.sky_condition t
WHERE t.id = "Key"::integer;
ELSE
RETURN QUERY
SELECT t.id, t.name
FROM catalog.sky_condition t
WHERE t.name LIKE "SearchValue"
ORDER BY t.name
LIMIT 1000;
END IF;
END $function$
*/
}
/**
* @function catalog_soil_class_l
* @memberof zzgll
* @description Catalog soil class l
* @param {character_varying} SearchValue
* @param {integer} Key
* @returns {Object} integer idcharacter_varying name
*/
function catalog_soil_class_l() {
/*
CREATE OR REPLACE FUNCTION zzgll.catalog_soil_class_l("SearchValue" character varying, "Key" integer DEFAULT NULL::integer)
RETURNS TABLE(id integer, name character varying)
LANGUAGE plpgsql
AS $function$
BEGIN
IF "Key" IS NOT NULL THEN
RETURN QUERY
SELECT t.id, t.name
FROM catalog.soil_class t
WHERE t.id = "Key"::integer;
ELSE
RETURN QUERY
SELECT t.id, t.name
FROM catalog.soil_class t
WHERE t.name LIKE "SearchValue"
ORDER BY t.name
LIMIT 1000;
END IF;
END $function$
*/
}
/**
* @function catalog_soil_moisture_method_l
* @memberof zzgll
* @description Catalog soil moisture method l
* @param {character_varying} SearchValue
* @param {integer} Key
* @returns {Object} integer idcharacter_varying name
*/
function catalog_soil_moisture_method_l() {
/*
CREATE OR REPLACE FUNCTION zzgll.catalog_soil_moisture_method_l("SearchValue" character varying, "Key" integer DEFAULT NULL::integer)
RETURNS TABLE(id integer, name character varying)
LANGUAGE plpgsql
AS $function$
BEGIN
IF "Key" IS NOT NULL THEN
RETURN QUERY
SELECT t.id, t.name
FROM catalog.soil_moisture_method t
WHERE t.id = "Key"::integer;
ELSE
RETURN QUERY
SELECT t.id, t.name
FROM catalog.soil_moisture_method t
WHERE t.name LIKE "SearchValue"
ORDER BY t.name
LIMIT 1000;
END IF;
END $function$
*/
}
/**
* @function catalog_soil_type_l
* @memberof zzgll
* @description Catalog soil type l
* @param {character_varying} SearchValue
* @param {integer} Key
* @returns {Object} integer idcharacter_varying name
*/
function catalog_soil_type_l() {
/*
CREATE OR REPLACE FUNCTION zzgll.catalog_soil_type_l("SearchValue" character varying, "Key" integer DEFAULT NULL::integer)
RETURNS TABLE(id integer, name character varying)
LANGUAGE plpgsql
AS $function$
BEGIN
IF "Key" IS NOT NULL THEN
RETURN QUERY
SELECT t.id, t.name
FROM catalog.soil_type t
WHERE t.id = "Key"::integer;
ELSE
RETURN QUERY
SELECT t.id, t.name
FROM catalog.soil_type t
WHERE t.name LIKE "SearchValue"
ORDER BY t.name
LIMIT 1000;
END IF;
END $function$
*/
}
/**
* @function catalog_spectra_prep_l
* @memberof zzgll
* @description Catalog spectra prep l
* @param {character_varying} SearchValue
* @param {integer} Key
* @returns {Object} integer idcharacter_varying name
*/
function catalog_spectra_prep_l() {
/*
CREATE OR REPLACE FUNCTION zzgll.catalog_spectra_prep_l("SearchValue" character varying, "Key" integer DEFAULT NULL::integer)
RETURNS TABLE(id integer, name character varying)
LANGUAGE plpgsql
AS $function$
BEGIN
IF "Key" IS NOT NULL THEN
RETURN QUERY
SELECT t.id, t.name
FROM catalog.spectra_prep t
WHERE t.id = "Key"::integer;
ELSE
RETURN QUERY
SELECT t.id, t.name
FROM catalog.spectra_prep t
WHERE t.name LIKE "SearchValue"
ORDER BY t.name
LIMIT 1000;
END IF;
END $function$
*/
}
/**
* @function catalog_spectroscopy_method_l
* @memberof zzgll
* @description Catalog spectroscopy method l
* @param {character_varying} SearchValue
* @param {integer} Key
* @returns {Object} integer idcharacter_varying name
*/
function catalog_spectroscopy_method_l() {
/*
CREATE OR REPLACE FUNCTION zzgll.catalog_spectroscopy_method_l("SearchValue" character varying, "Key" integer DEFAULT NULL::integer)
RETURNS TABLE(id integer, name character varying)
LANGUAGE plpgsql
AS $function$
BEGIN
IF "Key" IS NOT NULL THEN
RETURN QUERY
SELECT t.id, t.name
FROM catalog.spectroscopy_method t
WHERE t.id = "Key"::integer;
ELSE
RETURN QUERY
SELECT t.id, t.name
FROM catalog.spectroscopy_method t
WHERE t.name LIKE "SearchValue"
ORDER BY t.name
LIMIT 1000;
END IF;
END $function$
*/
}
/**
* @function catalog_storage_l
* @memberof zzgll
* @description Catalog storage l
* @param {character_varying} SearchValue
* @param {integer} Key
* @returns {Object} integer idcharacter_varying name
*/
function catalog_storage_l() {
/*
CREATE OR REPLACE FUNCTION zzgll.catalog_storage_l("SearchValue" character varying, "Key" integer DEFAULT NULL::integer)
RETURNS TABLE(id integer, name character varying)
LANGUAGE plpgsql
AS $function$
BEGIN
IF "Key" IS NOT NULL THEN
RETURN QUERY
SELECT t.id, t.name
FROM catalog.storage t
WHERE t.id = "Key"::integer;
ELSE
RETURN QUERY
SELECT t.id, t.name
FROM catalog.storage t
WHERE t.name LIKE "SearchValue"
ORDER BY t.name
LIMIT 1000;
END IF;
END $function$
*/
}
/**
* @function catalog_subsample_l
* @memberof zzgll
* @description Catalog subsample l
* @param {character_varying} SearchValue
* @param {integer} Key
* @returns {Object} integer idcharacter_varying name
*/
function catalog_subsample_l() {
/*
CREATE OR REPLACE FUNCTION zzgll.catalog_subsample_l("SearchValue" character varying, "Key" integer DEFAULT NULL::integer)
RETURNS TABLE(id integer, name character varying)
LANGUAGE plpgsql
AS $function$
BEGIN
IF "Key" IS NOT NULL THEN
RETURN QUERY
SELECT t.id, t.name
FROM catalog.subsample t
WHERE t.id = "Key"::integer;
ELSE
RETURN QUERY
SELECT t.id, t.name
FROM catalog.subsample t
WHERE t.name LIKE "SearchValue"
ORDER BY t.name
LIMIT 1000;
END IF;
END $function$
*/
}
/**
* @function catalog_taxa_status_l
* @memberof zzgll
* @description Catalog taxa status l
* @param {character_varying} SearchValue
* @param {integer} Key
* @returns {Object} integer idcharacter_varying name
*/
function catalog_taxa_status_l() {
/*
CREATE OR REPLACE FUNCTION zzgll.catalog_taxa_status_l("SearchValue" character varying, "Key" integer DEFAULT NULL::integer)
RETURNS TABLE(id integer, name character varying)
LANGUAGE plpgsql
AS $function$
BEGIN
IF "Key" IS NOT NULL THEN
RETURN QUERY
SELECT t.id, t.name
FROM catalog.taxa_status t
WHERE t.id = "Key"::integer;
ELSE
RETURN QUERY
SELECT t.id, t.name
FROM catalog.taxa_status t
WHERE t.name LIKE "SearchValue"
ORDER BY t.name
LIMIT 1000;
END IF;
END $function$
*/
}
/**
* @function catalog_transport_l
* @memberof zzgll
* @description Catalog transport l
* @param {character_varying} SearchValue
* @param {integer} Key
* @returns {Object} integer idcharacter_varying name
*/
function catalog_transport_l() {
/*
CREATE OR REPLACE FUNCTION zzgll.catalog_transport_l("SearchValue" character varying, "Key" integer DEFAULT NULL::integer)
RETURNS TABLE(id integer, name character varying)
LANGUAGE plpgsql
AS $function$
BEGIN
IF "Key" IS NOT NULL THEN
RETURN QUERY
SELECT t.id, t.name
FROM catalog.transport t
WHERE t.id = "Key"::integer;
ELSE
RETURN QUERY
SELECT t.id, t.name
FROM catalog.transport t
WHERE t.name LIKE "SearchValue"
ORDER BY t.name
LIMIT 1000;
END IF;
END $function$
*/
}
/**
* @function catalog_unit_l
* @memberof zzgll
* @description Catalog unit l
* @param {character_varying} SearchValue
* @param {integer} Key
* @returns {Object} integer idcharacter_varying name
*/
function catalog_unit_l() {
/*
CREATE OR REPLACE FUNCTION zzgll.catalog_unit_l("SearchValue" character varying, "Key" integer DEFAULT NULL::integer)
RETURNS TABLE(id integer, name character varying)
LANGUAGE plpgsql
AS $function$
BEGIN
IF "Key" IS NOT NULL THEN
RETURN QUERY
SELECT t.id, t.display_name
FROM catalog.unit t
WHERE t.id = "Key"::integer;
ELSE
RETURN QUERY
SELECT t.id, t.display_name
FROM catalog.unit t
WHERE t.display_name LIKE "SearchValue"
ORDER BY t.display_name
LIMIT 1000;
END IF;
END
$function$
*/
}
/**
* @function catalog_usda_standard_l
* @memberof zzgll
* @description Catalog usda standard l
* @param {character_varying} SearchValue
* @param {integer} Key
* @returns {Object} integer idcharacter_varying name
*/
function catalog_usda_standard_l() {
/*
CREATE OR REPLACE FUNCTION zzgll.catalog_usda_standard_l("SearchValue" character varying, "Key" integer DEFAULT NULL::integer)
RETURNS TABLE(id integer, name character varying)
LANGUAGE plpgsql
AS $function$
BEGIN
IF "Key" IS NOT NULL THEN
RETURN QUERY
SELECT t.id, t.name
FROM catalog.usda_standard t
WHERE t.id = "Key"::integer;
ELSE
RETURN QUERY
SELECT t.id, t.name
FROM catalog.usda_standard t
WHERE t.name LIKE "SearchValue"
ORDER BY t.name
LIMIT 1000;
END IF;
END $function$
*/
}
/**
* @function data_asset_catalog_l
* @memberof zzgll
* @description Data asset catalog l
* @param {character_varying} SearchValue
* @param {integer} Key
* @returns {Object}
* @property {integer} id
* @property {character_varying} name
*/
function data_asset_catalog_l() {
/*
CREATE OR REPLACE FUNCTION zzgll.data_asset_catalog_l("SearchValue" character varying, "Key" integer DEFAULT NULL::integer)
RETURNS TABLE(id integer, name character varying)
LANGUAGE plpgsql
AS $function$
BEGIN
IF "Key" IS NOT NULL THEN
RETURN QUERY
SELECT t.id, t.name
FROM data.asset_catalog t
WHERE t.id = "Key"::integer;
ELSE
RETURN QUERY
SELECT t.id, t.name
FROM data.asset_catalog t
WHERE t.name LIKE "SearchValue"
ORDER BY t.name
LIMIT 1000;
END IF;
END $function$
*/
}
/**
* @function data_asset_theme_l
* @memberof zzgll
* @description Data asset theme l
* @param {character_varying} SearchValue
* @param {integer} Key
* @returns {Object}
* @property {integer} id
* @property {character_varying} name
*/
function data_asset_theme_l() {
/*
CREATE OR REPLACE FUNCTION zzgll.data_asset_theme_l("SearchValue" character varying, "Key" integer DEFAULT NULL::integer)
RETURNS TABLE(id integer, name character varying)
LANGUAGE plpgsql
AS $function$
BEGIN
IF "Key" IS NOT NULL THEN
RETURN QUERY
SELECT t.id, t.name
FROM data.asset_theme t
WHERE t.id = "Key"::integer;
ELSE
RETURN QUERY
SELECT t.id, t.name
FROM data.asset_theme t
WHERE t.name LIKE "SearchValue"
ORDER BY t.name
LIMIT 1000;
END IF;
END $function$
*/
}
/**
* @function data_attribute_description_l
* @memberof zzgll
* @description Data attribute description l
* @param {character_varying} SearchValue
* @param {integer} Key
* @returns {Object} integer idcharacter_varying name
*/
function data_attribute_description_l() {
/*
CREATE OR REPLACE FUNCTION zzgll.data_attribute_description_l("SearchValue" character varying, "Key" integer DEFAULT NULL::integer)
RETURNS TABLE(id integer, name character varying)
LANGUAGE plpgsql
AS $function$
BEGIN
IF "Key" IS NOT NULL THEN
RETURN QUERY
SELECT t.id, t.name
FROM data.attribute_description t
WHERE t.id = "Key"::integer;
ELSE
RETURN QUERY
SELECT t.id, t.name
FROM data.attribute_description t
WHERE t.name LIKE "SearchValue"
ORDER BY t.name
LIMIT 1000;
END IF;
END $function$
*/
}
/**
* @function data_bioinformatic_treatment_l
* @memberof zzgll
* @description Data bioinformatic treatment l
* @param {character_varying} SearchValue
* @param {integer} Key
* @returns {Object} integer idcharacter_varying name
*/
function data_bioinformatic_treatment_l() {
/*
CREATE OR REPLACE FUNCTION zzgll.data_bioinformatic_treatment_l("SearchValue" character varying, "Key" integer DEFAULT NULL::integer)
RETURNS TABLE(id integer, name character varying)
LANGUAGE plpgsql
AS $function$
BEGIN
IF "Key" IS NOT NULL THEN
RETURN QUERY
SELECT t.id, t.name
FROM data.bioinformatic_treatment t
WHERE t.id = "Key"::integer;
ELSE
RETURN QUERY
SELECT t.id, t.name
FROM data.bioinformatic_treatment t
WHERE t.name LIKE "SearchValue"
ORDER BY t.name
LIMIT 1000;
END IF;
END $function$
*/
}
/**
* @function data_catalog_l
* @memberof zzgll
* @description Data catalog l
* @param {character_varying} SearchValue
* @param {integer} Key
* @returns {Object}
* @property {integer} id
* @property {character_varying} name
*/
function data_catalog_l() {
/*
CREATE OR REPLACE FUNCTION zzgll.data_catalog_l("SearchValue" character varying, "Key" integer DEFAULT NULL::integer)
RETURNS TABLE(id integer, name character varying)
LANGUAGE plpgsql
AS $function$
BEGIN
IF "Key" IS NOT NULL THEN
RETURN QUERY
SELECT t.id, t.name
FROM data.catalog t
WHERE t.id = "Key"::integer;
ELSE
RETURN QUERY
SELECT t.id, t.name
FROM data.catalog t
WHERE t.name LIKE "SearchValue"
ORDER BY t.name
LIMIT 1000;
END IF;
END $function$
*/
}
/**
* @function data_custom_geometry_l
* @memberof zzgll
* @description Data custom geometry l
* @param {character_varying} SearchValue
* @param {integer} Key
* @returns {Object}
* @property {integer} id
* @property {integer} geometry_type_id
*/
function data_custom_geometry_l() {
/*
CREATE OR REPLACE FUNCTION zzgll.data_custom_geometry_l("SearchValue" character varying, "Key" integer DEFAULT NULL::integer)
RETURNS TABLE(id integer, geometry_type_id integer)
LANGUAGE plpgsql
AS $function$
BEGIN
IF "Key" IS NOT NULL THEN
RETURN QUERY
SELECT t.id, t.geometry_type_id
FROM data.custom_geometry t
WHERE t.id = "Key"::integer;
ELSE
RETURN QUERY
SELECT t.id, t.geometry_type_id
FROM data.custom_geometry t
WHERE t.geometry_type_id LIKE "SearchValue"
ORDER BY t.geometry_type_id
LIMIT 1000;
END IF;
END $function$
*/
}
/**
* @function data_custom_geometry_time_l
* @memberof zzgll
* @description Data custom geometry time l
* @param {character_varying} SearchValue
* @param {integer} Key
* @returns {Object} integer idcharacter_varying custom_geometry_id
*/
function data_custom_geometry_time_l() {
/*
CREATE OR REPLACE FUNCTION zzgll.data_custom_geometry_time_l("SearchValue" character varying, "Key" integer DEFAULT NULL::integer)
RETURNS TABLE(id integer, custom_geometry_id character varying)
LANGUAGE plpgsql
AS $function$
BEGIN
IF "Key" IS NOT NULL THEN
RETURN QUERY
SELECT t.id, t.custom_geometry_id
FROM data.custom_geometry_time t
WHERE t.id = "Key"::integer;
ELSE
RETURN QUERY
SELECT t.id, t.custom_geometry_id
FROM data.custom_geometry_time t
WHERE t.custom_geometry_id LIKE "SearchValue"
ORDER BY t.custom_geometry_id
LIMIT 1000;
END IF;
END $function$
*/
}
/**
* @function data_data_source_l
* @memberof zzgll
* @description Data data source l
* @param {character_varying} SearchValue
* @param {integer} Key
* @returns {Object} integer idcharacter_varying name
*/
function data_data_source_l() {
/*
CREATE OR REPLACE FUNCTION zzgll.data_data_source_l("SearchValue" character varying, "Key" integer DEFAULT NULL::integer)
RETURNS TABLE(id integer, name character varying)
LANGUAGE plpgsql
AS $function$
BEGIN
IF "Key" IS NOT NULL THEN
RETURN QUERY
SELECT t.id, t.name
FROM data.data_source t
WHERE t.id = "Key"::integer;
ELSE
RETURN QUERY
SELECT t.id, t.name
FROM data.data_source t
WHERE t.name LIKE "SearchValue"
ORDER BY t.name
LIMIT 1000;
END IF;
END $function$
*/
}
/**
* @function data_date_style_l
* @memberof zzgll
* @description Data date style l
* @param {character_varying} SearchValue
* @param {integer} Key
* @returns {Object}
* @property {integer} id
* @property {character_varying} name
*/
function data_date_style_l() {
/*
CREATE OR REPLACE FUNCTION zzgll.data_date_style_l("SearchValue" character varying, "Key" integer DEFAULT NULL::integer)
RETURNS TABLE(id integer, name character varying)
LANGUAGE plpgsql
AS $function$
BEGIN
IF "Key" IS NOT NULL THEN
RETURN QUERY
SELECT t.id, t.name
FROM data.date_style t
WHERE t.id = "Key"::integer;
ELSE
RETURN QUERY
SELECT t.id, t.name
FROM data.date_style t
WHERE t.name LIKE "SearchValue"
ORDER BY t.name
LIMIT 1000;
END IF;
END $function$
*/
}
/**
* @function data_date_unit_l
* @memberof zzgll
* @description Data date unit l
* @param {character_varying} SearchValue
* @param {integer} Key
* @returns {Object}
* @property {integer} id
* @property {character_varying} name
*/
function data_date_unit_l() {
/*
CREATE OR REPLACE FUNCTION zzgll.data_date_unit_l("SearchValue" character varying, "Key" integer DEFAULT NULL::integer)
RETURNS TABLE(id integer, name character varying)
LANGUAGE plpgsql
AS $function$
BEGIN
IF "Key" IS NOT NULL THEN
RETURN QUERY
SELECT t.id, t.name
FROM data.date_unit t
WHERE t.id = "Key"::integer;
ELSE
RETURN QUERY
SELECT t.id, t.name
FROM data.date_unit t
WHERE t.name LIKE "SearchValue"
ORDER BY t.name
LIMIT 1000;
END IF;
END $function$
*/
}
/**
* @function data_depth_l
* @memberof zzgll
* @description Data depth l
* @param {character_varying} SearchValue
* @param {integer} Key
* @returns {Object} integer idcharacter_varying name
*/
function data_depth_l() {
/*
CREATE OR REPLACE FUNCTION zzgll.data_depth_l("SearchValue" character varying, "Key" integer DEFAULT NULL::integer)
RETURNS TABLE(id integer, name character varying)
LANGUAGE plpgsql
AS $function$
BEGIN
IF "Key" IS NOT NULL THEN
RETURN QUERY
SELECT t.id, t.name
FROM data.depth t
WHERE t.id = "Key"::integer;
ELSE
RETURN QUERY
SELECT t.id, t.name
FROM data.depth t
WHERE t.name LIKE "SearchValue"
ORDER BY t.name
LIMIT 1000;
END IF;
END $function$
*/
}
/**
* @function data_edna_l
* @memberof zzgll
* @description Data edna l
* @param {character_varying} SearchValue
* @param {integer} Key
* @returns {Object} integer idcharacter_varying accession_code
*/
function data_edna_l() {
/*
CREATE OR REPLACE FUNCTION zzgll.data_edna_l("SearchValue" character varying, "Key" integer DEFAULT NULL::integer)
RETURNS TABLE(id integer, accession_code character varying)
LANGUAGE plpgsql
AS $function$
BEGIN
IF "Key" IS NOT NULL THEN
RETURN QUERY
SELECT t.id, t.accession_code
FROM data.edna t
WHERE t.id = "Key"::integer;
ELSE
RETURN QUERY
SELECT t.id, t.accession_code
FROM data.edna t
WHERE t.accession_code LIKE "SearchValue"
ORDER BY t.accession_code
LIMIT 1000;
END IF;
END $function$
*/
}
/**
* @function data_enzyme_l
* @memberof zzgll
* @description Data enzyme l
* @param {character_varying} SearchValue
* @param {integer} Key
* @returns {Object} integer idcharacter_varying observation_id
*/
function data_enzyme_l() {
/*
CREATE OR REPLACE FUNCTION zzgll.data_enzyme_l("SearchValue" character varying, "Key" integer DEFAULT NULL::integer)
RETURNS TABLE(id integer, observation_id character varying)
LANGUAGE plpgsql
AS $function$
BEGIN
IF "Key" IS NOT NULL THEN
RETURN QUERY
SELECT t.id, t.observation_id
FROM data.enzyme t
WHERE t.id = "Key"::integer;
ELSE
RETURN QUERY
SELECT t.id, t.observation_id::varchar
FROM data.enzyme t
WHERE t.observation_id::varchar LIKE "SearchValue"
ORDER BY t.observation_id
LIMIT 1000;
END IF;
END $function$
*/
}
/**
* @function data_equipment_l
* @memberof zzgll
* @description Data equipment l
* @param {character_varying} SearchValue
* @param {integer} Key
* @returns {Object} integer idcharacter_varying modelinteger observation_type_idcharacter_varying observation_type_name
*/
function data_equipment_l() {
/*
CREATE OR REPLACE FUNCTION zzgll.data_equipment_l("SearchValue" character varying, "Key" integer DEFAULT NULL::integer)
RETURNS TABLE(id integer, model character varying, observation_type_id integer, observation_type_name character varying)
LANGUAGE plpgsql
AS $function$
BEGIN
IF "Key" IS NOT NULL THEN
RETURN QUERY
SELECT t.id, t.model, ot.id observation_type_id, ot.name observation_type_name
FROM data.equipment t
LEFT JOIN catalog.equipment_type et ON t.equipment_type_id = et.id
LEFT JOIN catalog.observation_type ot ON et.observation_type_id = ot.id
WHERE t.id = "Key"::integer;
ELSE
RETURN QUERY
SELECT t.id, t.model, ot.id observation_type_id, ot.name observation_type_name
FROM data.equipment t
LEFT JOIN catalog.equipment_type et ON t.equipment_type_id = et.id
LEFT JOIN catalog.observation_type ot ON et.observation_type_id = ot.id
WHERE t.model LIKE "SearchValue"
ORDER BY t.model
LIMIT 1000;
END IF;
END $function$
*/
}
/**
* @function data_file_category_l
* @memberof zzgll
* @description Data file category l
* @param {character_varying} SearchValue
* @param {integer} Key
* @returns {Object}
* @property {integer} id
* @property {character_varying} name
*/
function data_file_category_l() {
/*
CREATE OR REPLACE FUNCTION zzgll.data_file_category_l("SearchValue" character varying, "Key" integer DEFAULT NULL::integer)
RETURNS TABLE(id integer, name character varying)
LANGUAGE plpgsql
AS $function$
BEGIN
IF "Key" IS NOT NULL THEN
RETURN QUERY
SELECT t.id, t.name
FROM data.file_category t
WHERE t.id = "Key"::integer;
ELSE
RETURN QUERY
SELECT t.id, t.name
FROM data.file_category t
WHERE t.name LIKE "SearchValue"
ORDER BY t.name
LIMIT 1000;
END IF;
END $function$
*/
}
/**
* @function data_file_dataset_l
* @memberof zzgll
* @description Data file dataset l
* @param {character_varying} SearchValue
* @param {integer} Key
* @returns {Object}
* @property {integer} id
* @property {character_varying} name
*/
function data_file_dataset_l() {
/*
CREATE OR REPLACE FUNCTION zzgll.data_file_dataset_l("SearchValue" character varying, "Key" integer DEFAULT NULL::integer)
RETURNS TABLE(id integer, name character varying)
LANGUAGE plpgsql
AS $function$
BEGIN
IF "Key" IS NOT NULL THEN
RETURN QUERY
SELECT t.id, t.name
FROM data.file_dataset t
WHERE t.id = "Key"::integer;
ELSE
RETURN QUERY
SELECT t.id, t.name
FROM data.file_dataset t
WHERE t.name LIKE "SearchValue"
ORDER BY t.name
LIMIT 1000;
END IF;
END $function$
*/
}
/**
* @function data_file_metadata_l
* @memberof zzgll
* @description Data file metadata l
* @param {character_varying} SearchValue
* @param {integer} Key
* @returns {Object}
* @property {integer} id
* @property {character_varying} orig_id
*/
function data_file_metadata_l() {
/*
CREATE OR REPLACE FUNCTION zzgll.data_file_metadata_l("SearchValue" character varying, "Key" integer DEFAULT NULL::integer)
RETURNS TABLE(id integer, orig_id character varying)
LANGUAGE plpgsql
AS $function$
BEGIN
IF "Key" IS NOT NULL THEN
RETURN QUERY
SELECT t.id, t.orig_id
FROM data.file_metadata t
WHERE t.id = "Key"::integer;
ELSE
RETURN QUERY
SELECT t.id, t.orig_id
FROM data.file_metadata t
WHERE t.orig_id LIKE "SearchValue"
ORDER BY t.orig_id
LIMIT 1000;
END IF;
END $function$
*/
}
/**
* @function data_file_resolution_l
* @memberof zzgll
* @description Data file resolution l
* @param {character_varying} SearchValue
* @param {integer} Key
* @returns {Object}
* @property {integer} id
* @property {character_varying} name
*/
function data_file_resolution_l() {
/*
CREATE OR REPLACE FUNCTION zzgll.data_file_resolution_l("SearchValue" character varying, "Key" integer DEFAULT NULL::integer)
RETURNS TABLE(id integer, name character varying)
LANGUAGE plpgsql
AS $function$
BEGIN
IF "Key" IS NOT NULL THEN
RETURN QUERY
SELECT t.id, t.name
FROM data.file_resolution t
WHERE t.id = "Key"::integer;
ELSE
RETURN QUERY
SELECT t.id, t.name
FROM data.file_resolution t
WHERE t.name LIKE "SearchValue"
ORDER BY t.name
LIMIT 1000;
END IF;
END $function$
*/
}
/**
* @function data_file_scale_l
* @memberof zzgll
* @description Data file scale l
* @param {character_varying} SearchValue
* @param {integer} Key
* @returns {Object}
* @property {integer} id
* @property {character_varying} name
*/
function data_file_scale_l() {
/*
CREATE OR REPLACE FUNCTION zzgll.data_file_scale_l("SearchValue" character varying, "Key" integer DEFAULT NULL::integer)
RETURNS TABLE(id integer, name character varying)
LANGUAGE plpgsql
AS $function$
BEGIN
IF "Key" IS NOT NULL THEN
RETURN QUERY
SELECT t.id, t.name
FROM data.file_scale t
WHERE t.id = "Key"::integer;
ELSE
RETURN QUERY
SELECT t.id, t.name
FROM data.file_scale t
WHERE t.name LIKE "SearchValue"
ORDER BY t.name
LIMIT 1000;
END IF;
END $function$
*/
}
/**
* @function data_file_sd_type_l
* @memberof zzgll
* @description Data file sd type l
* @param {character_varying} SearchValue
* @param {integer} Key
* @returns {Object}
* @property {integer} id
* @property {character_varying} name
*/
function data_file_sd_type_l() {
/*
CREATE OR REPLACE FUNCTION zzgll.data_file_sd_type_l("SearchValue" character varying, "Key" integer DEFAULT NULL::integer)
RETURNS TABLE(id integer, name character varying)
LANGUAGE plpgsql
AS $function$
BEGIN
IF "Key" IS NOT NULL THEN
RETURN QUERY
SELECT t.id, t.name
FROM data.file_sd_type t
WHERE t.id = "Key"::integer;
ELSE
RETURN QUERY
SELECT t.id, t.name
FROM data.file_sd_type t
WHERE t.name LIKE "SearchValue"
ORDER BY t.name
LIMIT 1000;
END IF;
END $function$
*/
}
/**
* @function data_file_theme_l
* @memberof zzgll
* @description Data file theme l
* @param {character_varying} SearchValue
* @param {integer} Key
* @returns {Object}
* @property {integer} id
* @property {character_varying} name
*/
function data_file_theme_l() {
/*
CREATE OR REPLACE FUNCTION zzgll.data_file_theme_l("SearchValue" character varying, "Key" integer DEFAULT NULL::integer)
RETURNS TABLE(id integer, name character varying)
LANGUAGE plpgsql
AS $function$
BEGIN
IF "Key" IS NOT NULL THEN
RETURN QUERY
SELECT t.id, t.name
FROM data.file_theme t
WHERE t.id = "Key"::integer;
ELSE
RETURN QUERY
SELECT t.id, t.name
FROM data.file_theme t
WHERE t.name LIKE "SearchValue"
ORDER BY t.name
LIMIT 1000;
END IF;
END $function$
*/
}
/**
* @function data_file_type_l
* @memberof zzgll
* @description Data file type l
* @param {character_varying} SearchValue
* @param {integer} Key
* @returns {Object}
* @property {integer} id
* @property {character_varying} name
*/
function data_file_type_l() {
/*
CREATE OR REPLACE FUNCTION zzgll.data_file_type_l("SearchValue" character varying, "Key" integer DEFAULT NULL::integer)
RETURNS TABLE(id integer, name character varying)
LANGUAGE plpgsql
AS $function$
BEGIN
IF "Key" IS NOT NULL THEN
RETURN QUERY
SELECT t.id, t.name
FROM data.file_type t
WHERE t.id = "Key"::integer;
ELSE
RETURN QUERY
SELECT t.id, t.name
FROM data.file_type t
WHERE t.name LIKE "SearchValue"
ORDER BY t.name
LIMIT 1000;
END IF;
END $function$
*/
}
/**
* @function data_geometry_type_l
* @memberof zzgll
* @description Data geometry type l
* @param {character_varying} SearchValue
* @param {integer} Key
* @returns {Object} integer idcharacter_varying name
*/
function data_geometry_type_l() {
/*
CREATE OR REPLACE FUNCTION zzgll.data_geometry_type_l("SearchValue" character varying, "Key" integer DEFAULT NULL::integer)
RETURNS TABLE(id integer, name character varying)
LANGUAGE plpgsql
AS $function$
BEGIN
IF "Key" IS NOT NULL THEN
RETURN QUERY
SELECT t.id, t.name
FROM data.geometry_type t
WHERE t.id = "Key"::integer;
ELSE
RETURN QUERY
SELECT t.id, t.name
FROM data.geometry_type t
WHERE t.name LIKE "SearchValue"
ORDER BY t.name
LIMIT 1000;
END IF;
END $function$
*/
}
/**
* @function data_geometry_type_property_l
* @memberof zzgll
* @description Data geometry type property l
* @param {character_varying} SearchValue
* @param {integer} Key
* @returns {Object}
* @property {integer} id
* @property {integer} geometry_type_id
*/
function data_geometry_type_property_l() {
/*
CREATE OR REPLACE FUNCTION zzgll.data_geometry_type_property_l("SearchValue" character varying, "Key" integer DEFAULT NULL::integer)
RETURNS TABLE(id integer, geometry_type_id integer)
LANGUAGE plpgsql
AS $function$
BEGIN
IF "Key" IS NOT NULL THEN
RETURN QUERY
SELECT t.id, t.geometry_type_id
FROM data.geometry_type_property t
WHERE t.id = "Key"::integer;
ELSE
RETURN QUERY
SELECT t.id, t.geometry_type_id
FROM data.geometry_type_property t
WHERE t.geometry_type_id LIKE "SearchValue"
ORDER BY t.geometry_type_id
LIMIT 1000;
END IF;
END $function$
*/
}
/**
* @function data_indicator_l
* @memberof zzgll
* @description Data indicator l
* @param {character_varying} SearchValue
* @param {integer} Key
* @returns {Object} integer idcharacter_varying name
*/
function data_indicator_l() {
/*
CREATE OR REPLACE FUNCTION zzgll.data_indicator_l("SearchValue" character varying, "Key" integer DEFAULT NULL::integer)
RETURNS TABLE(id integer, name character varying)
LANGUAGE plpgsql
AS $function$
BEGIN
IF "Key" IS NOT NULL THEN
RETURN QUERY
SELECT t.id, t.display_name
FROM data.indicator t
WHERE t.id = "Key"::integer;
ELSE
RETURN QUERY
SELECT t.id, t.display_name
FROM data.indicator t
WHERE t.name LIKE "SearchValue"
ORDER BY t.display_name
LIMIT 1000;
END IF;
END $function$
*/
}
/**
* @function data_indicator_nn_l
* @memberof zzgll
* @description Data indicator nn l
* @param {character_varying} SearchValue
* @param {integer} Key
* @returns {Object} integer idcharacter_varying name
*/
function data_indicator_nn_l() {
/*
CREATE OR REPLACE FUNCTION zzgll.data_indicator_nn_l("SearchValue" character varying, "Key" integer DEFAULT NULL::integer)
RETURNS TABLE(id integer, name character varying)
LANGUAGE plpgsql
AS $function$
BEGIN
IF "Key" IS NOT NULL THEN
RETURN QUERY
SELECT t.id, t.display_name
FROM data.indicator t
WHERE t.id = "Key"::integer;
ELSE
RETURN QUERY
SELECT t.id, t.display_name
FROM data.indicator t
WHERE t.name LIKE "SearchValue" AND NOT t.numerical
ORDER BY t.display_name
LIMIT 1000;
END IF;
END $function$
*/
}
/**
* @function data_infiltration_l
* @memberof zzgll
* @description Data infiltration l
* @param {character_varying} SearchValue
* @param {integer} Key
* @returns {Object} integer idcharacter_varying observation_id
*/
function data_infiltration_l() {
/*
CREATE OR REPLACE FUNCTION zzgll.data_infiltration_l("SearchValue" character varying, "Key" integer DEFAULT NULL::integer)
RETURNS TABLE(id integer, observation_id character varying)
LANGUAGE plpgsql
AS $function$
BEGIN
IF "Key" IS NOT NULL THEN
RETURN QUERY
SELECT t.id, t.observation_id
FROM data.infiltration t
WHERE t.id = "Key"::integer;
ELSE
RETURN QUERY
SELECT t.id, t.observation_id::varchar
FROM data.infiltration t
WHERE t.observation_id::varchar LIKE "SearchValue"
ORDER BY t.observation_id
LIMIT 1000;
END IF;
END $function$
*/
}
/**
* @function data_lab_analysis_method_l
* @memberof zzgll
* @description Data lab analysis method l
* @param {character_varying} SearchValue
* @param {integer} Key
* @returns {Object} integer idcharacter_varying name
*/
function data_lab_analysis_method_l() {
/*
CREATE OR REPLACE FUNCTION zzgll.data_lab_analysis_method_l("SearchValue" character varying, "Key" integer DEFAULT NULL::integer)
RETURNS TABLE(id integer, name character varying)
LANGUAGE plpgsql
AS $function$
BEGIN
IF "Key" IS NOT NULL THEN
RETURN QUERY
SELECT t.id, t.name
FROM data.lab_analysis_method t
WHERE t.id = "Key"::integer;
ELSE
RETURN QUERY
SELECT t.id, t.name
FROM data.lab_analysis_method t
WHERE t.name LIKE "SearchValue"
ORDER BY t.name
LIMIT 1000;
END IF;
END $function$
*/
}
/**
* @function data_laboratory_l
* @memberof zzgll
* @description Data laboratory l
* @param {character_varying} SearchValue
* @param {integer} Key
* @returns {Object} integer idcharacter_varying name
*/
function data_laboratory_l() {
/*
CREATE OR REPLACE FUNCTION zzgll.data_laboratory_l("SearchValue" character varying, "Key" integer DEFAULT NULL::integer)
RETURNS TABLE(id integer, name character varying)
LANGUAGE plpgsql
AS $function$
BEGIN
IF "Key" IS NOT NULL THEN
RETURN QUERY
SELECT t.id, t.name
FROM data.laboratory t
WHERE t.id = "Key"::integer;
ELSE
RETURN QUERY
SELECT t.id, t.name
FROM data.laboratory t
WHERE t.name LIKE "SearchValue"
ORDER BY t.name
LIMIT 1000;
END IF;
END $function$
*/
}
/**
* @function data_lc_detail_l
* @memberof zzgll
* @description Data lc detail l
* @param {character_varying} SearchValue
* @param {integer} Key
* @returns {Object}
* @property {integer} id
* @property {character_varying} name
*/
function data_lc_detail_l() {
/*
CREATE OR REPLACE FUNCTION zzgll.data_lc_detail_l("SearchValue" character varying, "Key" integer DEFAULT NULL::integer)
RETURNS TABLE(id integer, name character varying)
LANGUAGE plpgsql
AS $function$
BEGIN
IF "Key" IS NOT NULL THEN
RETURN QUERY
SELECT t.id, t.name
FROM data.lc_detail t
WHERE t.id = "Key"::integer;
ELSE
RETURN QUERY
SELECT t.id, t.name
FROM data.lc_detail t
WHERE t.name LIKE "SearchValue"
ORDER BY t.name
LIMIT 1000;
END IF;
END $function$
*/
}
/**
* @function data_lc_l
* @memberof zzgll
* @description Data lc l
* @param {character_varying} SearchValue
* @param {integer} Key
* @returns {Object}
* @property {integer} id
* @property {character_varying} name
*/
function data_lc_l() {
/*
CREATE OR REPLACE FUNCTION zzgll.data_lc_l("SearchValue" character varying, "Key" integer DEFAULT NULL::integer)
RETURNS TABLE(id integer, name character varying)
LANGUAGE plpgsql
AS $function$
BEGIN
IF "Key" IS NOT NULL THEN
RETURN QUERY
SELECT t.id, t.name
FROM data.lc t
WHERE t.id = "Key"::integer;
ELSE
RETURN QUERY
SELECT t.id, t.name
FROM data.lc t
WHERE t.name LIKE "SearchValue"
ORDER BY t.name
LIMIT 1000;
END IF;
END $function$
*/
}
/**
* @function data_lc_main_l
* @memberof zzgll
* @description Data lc main l
* @param {character_varying} SearchValue
* @param {integer} Key
* @returns {Object}
* @property {integer} id
* @property {character_varying} name
*/
function data_lc_main_l() {
/*
CREATE OR REPLACE FUNCTION zzgll.data_lc_main_l("SearchValue" character varying, "Key" integer DEFAULT NULL::integer)
RETURNS TABLE(id integer, name character varying)
LANGUAGE plpgsql
AS $function$
BEGIN
IF "Key" IS NOT NULL THEN
RETURN QUERY
SELECT t.id, t.name
FROM data.lc_main t
WHERE t.id = "Key"::integer;
ELSE
RETURN QUERY
SELECT t.id, t.name
FROM data.lc_main t
WHERE t.name LIKE "SearchValue"
ORDER BY t.name
LIMIT 1000;
END IF;
END $function$
*/
}
/**
* @function data_license_l
* @memberof zzgll
* @description Data license l
* @param {character_varying} SearchValue
* @param {integer} Key
* @returns {Object}
* @property {integer} id
* @property {character_varying} name
*/
function data_license_l() {
/*
CREATE OR REPLACE FUNCTION zzgll.data_license_l("SearchValue" character varying, "Key" integer DEFAULT NULL::integer)
RETURNS TABLE(id integer, name character varying)
LANGUAGE plpgsql
AS $function$
BEGIN
IF "Key" IS NOT NULL THEN
RETURN QUERY
SELECT t.id, t.name
FROM data.license t
WHERE t.id = "Key"::integer;
ELSE
RETURN QUERY
SELECT t.id, t.name
FROM data.license t
WHERE t.name LIKE "SearchValue"
ORDER BY t.name
LIMIT 1000;
END IF;
END $function$
*/
}
/**
* @function data_lu_detail_l
* @memberof zzgll
* @description Data lu detail l
* @param {character_varying} SearchValue
* @param {integer} Key
* @returns {Object}
* @property {integer} id
* @property {character_varying} name
*/
function data_lu_detail_l() {
/*
CREATE OR REPLACE FUNCTION zzgll.data_lu_detail_l("SearchValue" character varying, "Key" integer DEFAULT NULL::integer)
RETURNS TABLE(id integer, name character varying)
LANGUAGE plpgsql
AS $function$
BEGIN
IF "Key" IS NOT NULL THEN
RETURN QUERY
SELECT t.id, t.name
FROM data.lu_detail t
WHERE t.id = "Key"::integer;
ELSE
RETURN QUERY
SELECT t.id, t.name
FROM data.lu_detail t
WHERE t.name LIKE "SearchValue"
ORDER BY t.name
LIMIT 1000;
END IF;
END $function$
*/
}
/**
* @function data_lu_l
* @memberof zzgll
* @description Data lu l
* @param {character_varying} SearchValue
* @param {integer} Key
* @returns {Object}
* @property {integer} id
* @property {character_varying} name
*/
function data_lu_l() {
/*
CREATE OR REPLACE FUNCTION zzgll.data_lu_l("SearchValue" character varying, "Key" integer DEFAULT NULL::integer)
RETURNS TABLE(id integer, name character varying)
LANGUAGE plpgsql
AS $function$
BEGIN
IF "Key" IS NOT NULL THEN
RETURN QUERY
SELECT t.id, t.name
FROM data.lu t
WHERE t.id = "Key"::integer;
ELSE
RETURN QUERY
SELECT t.id, t.name
FROM data.lu t
WHERE t.name LIKE "SearchValue"
ORDER BY t.name
LIMIT 1000;
END IF;
END $function$
*/
}
/**
* @function data_nucleotide_archive_l
* @memberof zzgll
* @description Data nucleotide archive l
* @param {character_varying} SearchValue
* @param {integer} Key
* @returns {Object} integer idcharacter_varying database_name
*/
function data_nucleotide_archive_l() {
/*
CREATE OR REPLACE FUNCTION zzgll.data_nucleotide_archive_l("SearchValue" character varying, "Key" integer DEFAULT NULL::integer)
RETURNS TABLE(id integer, database_name character varying)
LANGUAGE plpgsql
AS $function$
BEGIN
IF "Key" IS NOT NULL THEN
RETURN QUERY
SELECT t.id, t.database_name
FROM data.nucleotide_archive t
WHERE t.id = "Key"::integer;
ELSE
RETURN QUERY
SELECT t.id, t.database_name
FROM data.nucleotide_archive t
WHERE t.database_name LIKE "SearchValue"
ORDER BY t.database_name
LIMIT 1000;
END IF;
END $function$
*/
}
/**
* @function data_nuts_0_l
* @memberof zzgll
* @description Data nuts 0 l
* @param {character_varying} SearchValue
* @param {integer} Key
* @returns {Object}
* @property {integer} id
* @property {character_varying} name
*/
function data_nuts_0_l() {
/*
CREATE OR REPLACE FUNCTION zzgll.data_nuts_0_l("SearchValue" character varying, "Key" integer DEFAULT NULL::integer)
RETURNS TABLE(id integer, name character varying)
LANGUAGE plpgsql
AS $function$
BEGIN
IF "Key" IS NOT NULL THEN
RETURN QUERY
SELECT t.id, t.name
FROM data.nuts_0 t
WHERE t.id = "Key"::integer;
ELSE
RETURN QUERY
SELECT t.id, t.name
FROM data.nuts_0 t
WHERE t.name LIKE "SearchValue"
ORDER BY t.name
LIMIT 1000;
END IF;
END $function$
*/
}
/**
* @function data_nuts_1_l
* @memberof zzgll
* @description Data nuts 1 l
* @param {character_varying} SearchValue
* @param {integer} Key
* @returns {Object}
* @property {integer} id
* @property {character_varying} name
*/
function data_nuts_1_l() {
/*
CREATE OR REPLACE FUNCTION zzgll.data_nuts_1_l("SearchValue" character varying, "Key" integer DEFAULT NULL::integer)
RETURNS TABLE(id integer, name character varying)
LANGUAGE plpgsql
AS $function$
BEGIN
IF "Key" IS NOT NULL THEN
RETURN QUERY
SELECT t.id, t.name
FROM data.nuts_1 t
WHERE t.id = "Key"::integer;
ELSE
RETURN QUERY
SELECT t.id, t.name
FROM data.nuts_1 t
WHERE t.name LIKE "SearchValue"
ORDER BY t.name
LIMIT 1000;
END IF;
END $function$
*/
}
/**
* @function data_nuts_2_l
* @memberof zzgll
* @description Data nuts 2 l
* @param {character_varying} SearchValue
* @param {integer} Key
* @returns {Object}
* @property {integer} id
* @property {character_varying} name
*/
function data_nuts_2_l() {
/*
CREATE OR REPLACE FUNCTION zzgll.data_nuts_2_l("SearchValue" character varying, "Key" integer DEFAULT NULL::integer)
RETURNS TABLE(id integer, name character varying)
LANGUAGE plpgsql
AS $function$
BEGIN
IF "Key" IS NOT NULL THEN
RETURN QUERY
SELECT t.id, t.name
FROM data.nuts_2 t
WHERE t.id = "Key"::integer;
ELSE
RETURN QUERY
SELECT t.id, t.name
FROM data.nuts_2 t
WHERE t.name LIKE "SearchValue"
ORDER BY t.name
LIMIT 1000;
END IF;
END $function$
*/
}
/**
* @function data_nuts_3_l
* @memberof zzgll
* @description Data nuts 3 l
* @param {character_varying} SearchValue
* @param {integer} Key
* @returns {Object}
* @property {integer} id
* @property {character_varying} name
*/
function data_nuts_3_l() {
/*
CREATE OR REPLACE FUNCTION zzgll.data_nuts_3_l("SearchValue" character varying, "Key" integer DEFAULT NULL::integer)
RETURNS TABLE(id integer, name character varying)
LANGUAGE plpgsql
AS $function$
BEGIN
IF "Key" IS NOT NULL THEN
RETURN QUERY
SELECT t.id, t.name
FROM data.nuts_3 t
WHERE t.id = "Key"::integer;
ELSE
RETURN QUERY
SELECT t.id, t.name
FROM data.nuts_3 t
WHERE t.name LIKE "SearchValue"
ORDER BY t.name
LIMIT 1000;
END IF;
END $function$
*/
}
/**
* @function data_observation_l
* @memberof zzgll
* @description Data observation l
* @param {character_varying} SearchValue
* @param {integer} Key
* @returns {Object} integer idcharacter_varying comment
*/
function data_observation_l() {
/*
CREATE OR REPLACE FUNCTION zzgll.data_observation_l("SearchValue" character varying, "Key" integer DEFAULT NULL::integer)
RETURNS TABLE(id integer, comment character varying)
LANGUAGE plpgsql
AS $function$
BEGIN
IF "Key" IS NOT NULL THEN
RETURN QUERY
SELECT t.id, t.comment
FROM data.observation t
WHERE t.id = "Key"::integer;
ELSE
RETURN QUERY
SELECT t.id, t.comment
FROM data.observation t
WHERE t.comment LIKE "SearchValue"
ORDER BY t.comment
LIMIT 1000;
END IF;
END $function$
*/
}
/**
* @function data_pilot_l
* @memberof zzgll
* @description Data pilot l
* @param {character_varying} SearchValue
* @param {integer} Key
* @returns {Object} integer idcharacter_varying name
*/
function data_pilot_l() {
/*
CREATE OR REPLACE FUNCTION zzgll.data_pilot_l("SearchValue" character varying, "Key" integer DEFAULT NULL::integer)
RETURNS TABLE(id integer, name character varying)
LANGUAGE plpgsql
AS $function$
BEGIN
IF "Key" IS NOT NULL THEN
RETURN QUERY
SELECT t.id, t.name
FROM data.pilot t
WHERE t.id = "Key"::integer;
ELSE
RETURN QUERY
SELECT t.id, t.name
FROM data.pilot t
WHERE t.name LIKE "SearchValue"
ORDER BY t.name
LIMIT 1000;
END IF;
END $function$
*/
}
/**
* @function data_point_l
* @memberof zzgll
* @description Data point l
* @param {character_varying} SearchValue
* @param {integer} Key
* @returns {Object} integer idcharacter_varying point_key
*/
function data_point_l() {
/*
CREATE OR REPLACE FUNCTION zzgll.data_point_l("SearchValue" character varying, "Key" integer DEFAULT NULL::integer)
RETURNS TABLE(id integer, point_key character varying)
LANGUAGE plpgsql
AS $function$
BEGIN
IF "Key" IS NOT NULL THEN
RETURN QUERY
SELECT t.id, t.point_key
FROM data.point t
WHERE t.id = "Key"::integer;
ELSE
RETURN QUERY
SELECT t.id, t.point_key
FROM data.point t
WHERE t.point_key LIKE "SearchValue"
ORDER BY t.point_key
LIMIT 1000;
END IF;
END $function$
*/
}
/**
* @function data_property_l
* @memberof zzgll
* @description Data property l
* @param {character_varying} SearchValue
* @param {integer} Key
* @returns {Object} integer idcharacter_varying name
*/
function data_property_l() {
/*
CREATE OR REPLACE FUNCTION zzgll.data_property_l("SearchValue" character varying, "Key" integer DEFAULT NULL::integer)
RETURNS TABLE(id integer, name character varying)
LANGUAGE plpgsql
AS $function$
BEGIN
IF "Key" IS NOT NULL THEN
RETURN QUERY
SELECT t.id, COALESCE(t.name, i.name) name
FROM data.property t
LEFT JOIN data.indicator i ON i.id = t.indicator_id
WHERE t.id = "Key"::integer;
ELSE
RETURN QUERY
SELECT t.id, COALESCE(t.name, i.name) name
FROM data.property t
LEFT JOIN data.indicator i ON i.id = t.indicator_id
WHERE COALESCE(t.name, i.name) LIKE "SearchValue"
ORDER BY 2
LIMIT 1000;
END IF;
END $function$
*/
}
/**
* @function data_property_type_l
* @memberof zzgll
* @description Data property type l
* @param {character_varying} SearchValue
* @param {integer} Key
* @returns {Object}
* @property {integer} id
* @property {character_varying} name
*/
function data_property_type_l() {
/*
CREATE OR REPLACE FUNCTION zzgll.data_property_type_l("SearchValue" character varying, "Key" integer DEFAULT NULL::integer)
RETURNS TABLE(id integer, name character varying)
LANGUAGE plpgsql
AS $function$
BEGIN
IF "Key" IS NOT NULL THEN
RETURN QUERY
SELECT t.id, t.name
FROM data.property_type t
WHERE t.id = "Key"::integer;
ELSE
RETURN QUERY
SELECT t.id, t.name
FROM data.property_type t
WHERE t.name LIKE "SearchValue"
ORDER BY t.name
LIMIT 1000;
END IF;
END $function$
*/
}
/**
* @function data_sample_l
* @memberof zzgll
* @description Data sample l
* @param {character_varying} SearchValue
* @param {integer} Key
* @returns {Object} integer idcharacter_varying point_id
*/
function data_sample_l() {
/*
CREATE OR REPLACE FUNCTION zzgll.data_sample_l("SearchValue" character varying, "Key" integer DEFAULT NULL::integer)
RETURNS TABLE(id integer, point_id character varying)
LANGUAGE plpgsql
AS $function$
BEGIN
IF "Key" IS NOT NULL THEN
RETURN QUERY
SELECT t.id, t.name
FROM data.sample t
WHERE t.id = "Key"::integer;
ELSE
RETURN QUERY
SELECT t.id, t.name
FROM data.sample t
WHERE t.name LIKE "SearchValue"
ORDER BY t.name
LIMIT 1000;
END IF;
END $function$
*/
}
/**
* @function data_sampling_log_l
* @memberof zzgll
* @description Data sampling log l
* @param {character_varying} SearchValue
* @param {integer} Key
* @returns {Object} integer idcharacter_varying name
*/
function data_sampling_log_l() {
/*
CREATE OR REPLACE FUNCTION zzgll.data_sampling_log_l("SearchValue" character varying, "Key" integer DEFAULT NULL::integer)
RETURNS TABLE(id integer, name character varying)
LANGUAGE plpgsql
AS $function$
BEGIN
IF "Key" IS NOT NULL THEN
RETURN QUERY
SELECT t.id, t.name
FROM data.sampling_log t
WHERE t.id = "Key"::int;
ELSE
RETURN QUERY
SELECT t.id, t.name
FROM data.sampling_log t
WHERE t.name LIKE "SearchValue"
ORDER BY t.name
LIMIT 1000;
END IF;
END $function$
*/
}
/**
* @function data_shape_l
* @memberof zzgll
* @description Data shape l
* @param {character_varying} SearchValue
* @param {integer} Key
* @returns {Object}
* @property {integer} id
* @property {integer} data_source_id
*/
function data_shape_l() {
/*
CREATE OR REPLACE FUNCTION zzgll.data_shape_l("SearchValue" character varying, "Key" integer DEFAULT NULL::integer)
RETURNS TABLE(id integer, data_source_id integer)
LANGUAGE plpgsql
AS $function$
BEGIN
IF "Key" IS NOT NULL THEN
RETURN QUERY
SELECT t.id, t.data_source_id
FROM data.shape t
WHERE t.id = "Key"::integer;
ELSE
RETURN QUERY
SELECT t.id, t.data_source_id
FROM data.shape t
WHERE t.data_source_id LIKE "SearchValue"
ORDER BY t.data_source_id
LIMIT 1000;
END IF;
END $function$
*/
}
/**
* @function data_shdc_l
* @memberof zzgll
* @description Data shdc l
* @param {character_varying} SearchValue
* @param {integer} Key
* @returns {Object} integer idcharacter_varying property
*/
function data_shdc_l() {
/*
CREATE OR REPLACE FUNCTION zzgll.data_shdc_l("SearchValue" character varying, "Key" integer DEFAULT NULL::integer)
RETURNS TABLE(id integer, property character varying)
LANGUAGE plpgsql
AS $function$
BEGIN
IF "Key" IS NOT NULL THEN
RETURN QUERY
SELECT t.id, t.property
FROM data.shdc t
WHERE t.id = "Key"::integer;
ELSE
RETURN QUERY
SELECT t.id, t.property
FROM data.shdc t
WHERE t.property LIKE "SearchValue"
ORDER BY t.property
LIMIT 1000;
END IF;
END $function$
*/
}
/**
* @function data_shdc_property_l
* @memberof zzgll
* @description Data shdc property l
* @param {character_varying} SearchValue
* @param {integer} Key
* @returns {Object} integer idcharacter_varying property
*/
function data_shdc_property_l() {
/*
CREATE OR REPLACE FUNCTION zzgll.data_shdc_property_l("SearchValue" character varying, "Key" integer DEFAULT NULL::integer)
RETURNS TABLE(id integer, property character varying)
LANGUAGE plpgsql
AS $function$
BEGIN
IF "Key" IS NOT NULL THEN
RETURN QUERY
SELECT t.id, t.property
FROM data.shdc_property t
WHERE t.id = "Key"::integer;
ELSE
RETURN QUERY
SELECT t.id, t.property
FROM data.shdc_property t
WHERE t.property LIKE "SearchValue"
ORDER BY t.property
LIMIT 1000;
END IF;
END $function$
*/
}
/**
* @function data_simple_observation_l
* @memberof zzgll
* @description Data simple observation l
* @param {character_varying} SearchValue
* @param {integer} Key
* @returns {Object} integer idcharacter_varying indicator_id
*/
function data_simple_observation_l() {
/*
CREATE OR REPLACE FUNCTION zzgll.data_simple_observation_l("SearchValue" character varying, "Key" integer DEFAULT NULL::integer)
RETURNS TABLE(id integer, indicator_id character varying)
LANGUAGE plpgsql
AS $function$
BEGIN
IF "Key" IS NOT NULL THEN
RETURN QUERY
SELECT t.id, t.indicator_id
FROM data.simple_observation t
WHERE t.id = "Key"::integer;
ELSE
RETURN QUERY
SELECT t.id, t.indicator_id
FROM data.simple_observation t
WHERE t.indicator_id LIKE "SearchValue"
ORDER BY t.indicator_id
LIMIT 1000;
END IF;
END $function$
*/
}
/**
* @function data_site_l
* @memberof zzgll
* @description Data site l
* @param {character_varying} SearchValue
* @param {integer} Key
* @returns {Object} integer idcharacter_varying name
*/
function data_site_l() {
/*
CREATE OR REPLACE FUNCTION zzgll.data_site_l("SearchValue" character varying, "Key" integer DEFAULT NULL::integer)
RETURNS TABLE(id integer, name character varying)
LANGUAGE plpgsql
AS $function$
BEGIN
IF "Key" IS NOT NULL THEN
RETURN QUERY
SELECT t.id, t.name
FROM data.site t
WHERE t.id = "Key"::integer;
ELSE
RETURN QUERY
SELECT t.id, t.name
FROM data.site t
WHERE t.name LIKE "SearchValue"
ORDER BY t.name
LIMIT 1000;
END IF;
END $function$
*/
}
/**
* @function data_taxa_function_l
* @memberof zzgll
* @description Data taxa function l
* @param {character_varying} SearchValue
* @param {integer} Key
* @returns {Object} integer idcharacter_varying name
*/
function data_taxa_function_l() {
/*
CREATE OR REPLACE FUNCTION zzgll.data_taxa_function_l("SearchValue" character varying, "Key" integer DEFAULT NULL::integer)
RETURNS TABLE(id integer, name character varying)
LANGUAGE plpgsql
AS $function$
BEGIN
IF "Key" IS NOT NULL THEN
RETURN QUERY
SELECT t.id, t.name
FROM data.taxa_function t
WHERE t.id = "Key"::integer;
ELSE
RETURN QUERY
SELECT t.id, t.name
FROM data.taxa_function t
WHERE t.name LIKE "SearchValue"
ORDER BY t.name
LIMIT 1000;
END IF;
END $function$
*/
}
/**
* @function data_taxa_heterogeneity_l
* @memberof zzgll
* @description Data taxa heterogeneity l
* @param {character_varying} SearchValue
* @param {integer} Key
* @returns {Object} integer idcharacter_varying id_char
*/
function data_taxa_heterogeneity_l() {
/*
CREATE OR REPLACE FUNCTION zzgll.data_taxa_heterogeneity_l("SearchValue" character varying, "Key" integer DEFAULT NULL::integer)
RETURNS TABLE(id integer, id_char character varying)
LANGUAGE plpgsql
AS $function$
BEGIN
IF "Key" IS NOT NULL THEN
RETURN QUERY
SELECT t.id, t.id
FROM data.taxa_heterogeneity t
WHERE t.id = "Key"::int;
ELSE
RETURN QUERY
SELECT t.id, t.id::varchar
FROM data.taxa_heterogeneity t
WHERE t.id::varchar LIKE "SearchValue"
ORDER BY t.id
LIMIT 1000;
END IF;
END $function$
*/
}
/**
* @function data_taxa_l
* @memberof zzgll
* @description Data taxa l
* @param {character_varying} SearchValue
* @param {integer} Key
* @returns {Object} integer idcharacter_varying name
*/
function data_taxa_l() {
/*
CREATE OR REPLACE FUNCTION zzgll.data_taxa_l("SearchValue" character varying, "Key" integer DEFAULT NULL::integer)
RETURNS TABLE(id integer, name character varying)
LANGUAGE plpgsql
AS $function$
BEGIN
IF "Key" IS NOT NULL THEN
RETURN QUERY
SELECT t.id, (t.latin_name || ' (' || l.name || ')')::character varying
FROM data.taxa t
WHERE t.id = "Key"::int;
ELSE
RETURN QUERY
SELECT t.id, (t.latin_name || ' (' || l.name || CASE WHEN t.synonym THEN ', synonym' ELSE '' END || ')')::character varying
FROM data.taxa t
LEFT JOIN catalog.taxa_level l ON t.taxa_level_id = l.id
WHERE t.latin_name LIKE "SearchValue"
ORDER BY t.latin_name
LIMIT 1000;
END IF;
END $function$
*/
}
/**
* @function data_theme_l
* @memberof zzgll
* @description Data theme l
* @param {character_varying} SearchValue
* @param {integer} Key
* @returns {Object}
* @property {integer} id
* @property {character_varying} name
*/
function data_theme_l() {
/*
CREATE OR REPLACE FUNCTION zzgll.data_theme_l("SearchValue" character varying, "Key" integer DEFAULT NULL::integer)
RETURNS TABLE(id integer, name character varying)
LANGUAGE plpgsql
AS $function$
BEGIN
IF "Key" IS NOT NULL THEN
RETURN QUERY
SELECT t.id, t.name
FROM data.theme t
WHERE t.id = "Key"::integer;
ELSE
RETURN QUERY
SELECT t.id, t.name
FROM data.theme t
WHERE t.name LIKE "SearchValue"
ORDER BY t.name
LIMIT 1000;
END IF;
END $function$
*/
}
/**
* @function data_vw_asset_l
* @memberof zzgll
* @description Data vw asset l
* @param {character_varying} SearchValue
* @param {integer} Key
* @returns {Object} integer valuetext labelcharacter_varying urlcharacter_varying scale_factorinteger no_data
*/
function data_vw_asset_l() {
/*
CREATE OR REPLACE FUNCTION zzgll.data_vw_asset_l("SearchValue" character varying, "Key" integer)
RETURNS TABLE(value integer, label text, url character varying, scale_factor character varying, no_data integer)
LANGUAGE plpgsql
AS $function$
BEGIN
--RETURN QUERY
--SELECT (row_number() OVER (ORDER BY title, depth, time_span))::int value, title || ' ' || depth || ' ' || time_span label, a.url, a.scale_factor
--FROM data.vw_asset a
--WHERE a.title ILIKE '%' || "SearchValue" || '%'
--ORDER BY 2;
RETURN QUERY
SELECT (
row_number() OVER (ORDER BY a.id))::int value,
i.name || ' ' || d.name || ' ' || f.temporal_coverage_start || '-' || f.temporal_coverage_end || ' ' || f.value label,
f.wasabi_link url,
a.scale_factor::varchar,
a.no_data
FROM data.shdc a
INNER JOIN data.shdc_file f ON f.shdc_id = a.id
INNER JOIN data.indicator i ON i.id = a.indicator_id
LEFT JOIN data.depth d ON f.depth_id = d.id
WHERE i.name ILIKE '%' || "SearchValue" || '%'
ORDER BY 2;
END $function$
*/
}
/**
* @function general_color_l
* @memberof zzgll
* @description General color l
* @param {character_varying} SearchValue
* @param {integer} Key
* @returns {Object} integer idcharacter_varying name
*/
function general_color_l() {
/*
CREATE OR REPLACE FUNCTION zzgll.general_color_l("SearchValue" character varying, "Key" integer DEFAULT NULL::integer)
RETURNS TABLE(id integer, name text, code character varying, color_name character varying)
LANGUAGE plpgsql
AS $function$
BEGIN
IF "Key" IS NOT NULL THEN
RETURN QUERY
SELECT t.id, '<span class="c-b" style="background-color:' || t.code || '"></span>' || t.name, t.code, t.name
FROM general.color t
WHERE t.id = "Key"::integer;
ELSE
RETURN QUERY
SELECT t.id, '<span class="c-b" style="background-color:' || t.code || '"></span>' || t.name, t.code, t.name
FROM general.color t
WHERE t.name LIKE "SearchValue"
ORDER BY t.name
LIMIT 1000;
END IF;
END $function$
*/
}
/**
* @function general_country_l
* @memberof zzgll
* @description General country l
* @param {character_varying} SearchValue
* @param {integer} Key
* @returns {Object} integer idcharacter_varying name
*/
function general_country_l() {
/*
CREATE OR REPLACE FUNCTION zzgll.general_country_l("SearchValue" character varying, "Key" integer DEFAULT NULL::integer)
RETURNS TABLE(id integer, name character varying)
LANGUAGE plpgsql
AS $function$
BEGIN
IF "Key" IS NOT NULL THEN
RETURN QUERY
SELECT t.id, t.name
FROM general.country t
WHERE t.id = "Key"::integer;
ELSE
RETURN QUERY
SELECT t.id, t.name
FROM general.country t
WHERE t.name LIKE "SearchValue"
ORDER BY t.name
LIMIT 1000;
END IF;
END $function$
*/
}
/**
* @function general_email_provider_d_overload
* @overload general_email_provider_d
* @memberof zzgll
* @description General email provider d
* @param {integer} Key
* @returns {void}
*/
function general_email_provider_d_overload() {
/*
CREATE OR REPLACE FUNCTION zzgll.general_email_provider_d("Key" integer)
RETURNS void
LANGUAGE plpgsql
AS $function$
BEGIN
DELETE FROM general.email_provider WHERE id = "Key";
END;
$function$
*/
}
/**
* @function general_email_provider_l
* @memberof zzgll
* @description General email provider l
* @param {character_varying} SearchValue
* @param {integer} Key
* @returns {Object} integer idcharacter_varying name
*/
function general_email_provider_l() {
/*
CREATE OR REPLACE FUNCTION zzgll.general_email_provider_l("SearchValue" character varying, "Key" integer DEFAULT NULL::integer)
RETURNS TABLE(id integer, name character varying)
LANGUAGE plpgsql
AS $function$
BEGIN
IF "Key" IS NOT NULL THEN
RETURN QUERY
SELECT t.id, t.name
FROM general.email_provider t
WHERE t.id = "Key"::integer;
ELSE
RETURN QUERY
SELECT t.id, t.name
FROM general.email_provider t
WHERE t.name LIKE "SearchValue"
ORDER BY t.name
LIMIT 1000;
END IF;
END $function$
*/
}
/**
* @function general_email_ssl_l
* @memberof zzgll
* @description General email ssl l
* @param {character_varying} SearchValue
* @param {integer} Key
* @returns {Object} integer idcharacter_varying name
*/
function general_email_ssl_l() {
/*
CREATE OR REPLACE FUNCTION zzgll.general_email_ssl_l("SearchValue" character varying, "Key" integer DEFAULT NULL::integer)
RETURNS TABLE(id integer, name character varying)
LANGUAGE plpgsql
AS $function$
BEGIN
IF "Key" IS NOT NULL THEN
RETURN QUERY
SELECT t.id, t.name
FROM general.email_ssl t
WHERE t.id = "Key"::int;
ELSE
RETURN QUERY
SELECT t.id, t.name
FROM general.email_ssl t
WHERE t.name LIKE "SearchValue"
ORDER BY t.name
LIMIT 1000;
END IF;
END $function$
*/
}
/**
* @function general_method_l
* @memberof zzgll
* @description General method l
* @param {character_varying} SearchValue
* @param {integer} Key
* @returns {Object} integer idcharacter_varying name
*/
function general_method_l() {
/*
CREATE OR REPLACE FUNCTION zzgll.general_method_l("SearchValue" character varying, "Key" integer DEFAULT NULL::integer)
RETURNS TABLE(id integer, name character varying)
LANGUAGE plpgsql
AS $function$
BEGIN
IF "Key" IS NOT NULL THEN
RETURN QUERY
SELECT t.id, t.name
FROM general.method t
WHERE t.id = "Key"::integer;
ELSE
RETURN QUERY
SELECT t.id, t.name
FROM general.method t
WHERE t.name LIKE "SearchValue"
ORDER BY t.name
LIMIT 1000;
END IF;
END $function$
*/
}
/**
* @function general_mjesto_l
* @memberof zzgll
* @description General mjesto l
* @param {character_varying} SearchValue
* @param {integer} Key
* @returns {Object}
* @property {integer} id
* @property {character_varying} name
*/
function general_mjesto_l() {
/*
CREATE OR REPLACE FUNCTION zzgll.general_mjesto_l("SearchValue" character varying, "Key" integer DEFAULT NULL::integer)
RETURNS TABLE(id integer, name character varying)
LANGUAGE plpgsql
AS $function$
BEGIN
IF "Key" IS NOT NULL THEN
RETURN QUERY
SELECT t.id, t.name
FROM general.mjesto t
WHERE t.id = "Key"::integer;
ELSE
RETURN QUERY
SELECT t.id, t.name
FROM general.mjesto t
WHERE t.name LIKE "SearchValue"
ORDER BY t.name
LIMIT 1000;
END IF;
END $function$
*/
}
/**
* @function general_nuts_l
* @memberof zzgll
* @description General nuts l
* @param {character_varying} SearchValue
* @param {integer} Key
* @returns {Object} integer idcharacter_varying nuts_id
*/
function general_nuts_l() {
/*
CREATE OR REPLACE FUNCTION zzgll.general_nuts_l("SearchValue" character varying, "Key" integer DEFAULT NULL::integer)
RETURNS TABLE(id integer, nuts_id character varying)
LANGUAGE plpgsql
AS $function$
BEGIN
IF "Key" IS NOT NULL THEN
RETURN QUERY
SELECT t.id, t.nuts_id
FROM general.nuts t
WHERE t.id = "Key"::integer;
ELSE
RETURN QUERY
SELECT t.id, t.nuts_id
FROM general.nuts t
WHERE t.nuts_id LIKE "SearchValue"
ORDER BY t.nuts_id
LIMIT 1000;
END IF;
END $function$
*/
}
/**
* @function general_partner_l
* @memberof zzgll
* @description General partner l
* @param {character_varying} SearchValue
* @param {integer} Key
* @returns {Object}
* @property {integer} id
* @property {character_varying} name
*/
function general_partner_l() {
/*
CREATE OR REPLACE FUNCTION zzgll.general_partner_l("SearchValue" character varying, "Key" integer DEFAULT NULL::integer)
RETURNS TABLE(id integer, name character varying)
LANGUAGE plpgsql
AS $function$
BEGIN
IF "Key" IS NOT NULL THEN
RETURN QUERY
SELECT t.id, t.short_name
FROM general.partner t
WHERE t.id = "Key"::integer;
ELSE
RETURN QUERY
SELECT t.id, t.short_name
FROM general.partner t
WHERE t.name LIKE "SearchValue"
ORDER BY t.name
LIMIT 1000;
END IF;
END $function$
*/
}
/**
* @function general_region_l
* @memberof zzgll
* @description General region l
* @param {character_varying} SearchValue
* @param {integer} Key
* @returns {Object} integer idcharacter_varying name
*/
function general_region_l() {
/*
CREATE OR REPLACE FUNCTION zzgll.general_region_l("SearchValue" character varying, "Key" integer DEFAULT NULL::integer)
RETURNS TABLE(id integer, name character varying)
LANGUAGE plpgsql
AS $function$
BEGIN
IF "Key" IS NOT NULL THEN
RETURN QUERY
SELECT t.id, t.name
FROM general.region t
WHERE t.id = "Key"::integer;
ELSE
RETURN QUERY
SELECT t.id, t.name
FROM general.region t
WHERE t.name LIKE "SearchValue"
ORDER BY t.name
LIMIT 1000;
END IF;
END $function$
*/
}
/**
* @function general_sub_region_l
* @memberof zzgll
* @description General sub region l
* @param {character_varying} SearchValue
* @param {integer} Key
* @returns {Object} integer idcharacter_varying name
*/
function general_sub_region_l() {
/*
CREATE OR REPLACE FUNCTION zzgll.general_sub_region_l("SearchValue" character varying, "Key" integer DEFAULT NULL::integer)
RETURNS TABLE(id integer, name character varying)
LANGUAGE plpgsql
AS $function$
BEGIN
IF "Key" IS NOT NULL THEN
RETURN QUERY
SELECT t.id, t.name
FROM general.sub_region t
WHERE t.id = "Key"::integer;
ELSE
RETURN QUERY
SELECT t.id, t.name
FROM general.sub_region t
WHERE t.name LIKE "SearchValue"
ORDER BY t.name
LIMIT 1000;
END IF;
END $function$
*/
}
/**
* @function get_lucas_sources
* @memberof zzgll
* @description Get Lucas Sources
* @param {character_varying} SearchValue
* @param {uuid} Key
* @returns {Object}
* @property {uuid} id
* @property {character_varying} name
*/
function get_lucas_sources() {
/*
CREATE OR REPLACE FUNCTION zzgll.get_lucas_sources("SearchValue" character varying, "Key" integer DEFAULT NULL::integer)
RETURNS TABLE(id integer, name character varying)
LANGUAGE plpgsql
AS $function$
BEGIN
RETURN QUERY
SELECT t.id value, t.name label
FROM data.data_source t
WHERE t.name LIKE 'LUCAS%'
--WHERE t.name LIKE "SearchValue" AND t.tenant_id = 1
ORDER BY t.name;
END $function$
*/
}
/**
* @function get_lucas_sources
_overload
* @overload get_lucas_sources
* @memberof zzgll
* @description Get Lucas Sources
* @param {character_varying} SearchValue
* @param {uuid} Key
* @returns {Object}
* @property {uuid} id
* @property {character_varying} name
*/
function get_lucas_sources_overload() {
/*
CREATE OR REPLACE FUNCTION zzgll.get_lucas_sources("SearchValue" character varying, "Key" uuid DEFAULT NULL::uuid)
RETURNS TABLE(id uuid, name character varying)
LANGUAGE plpgsql
AS $function$
BEGIN
RETURN QUERY
SELECT t.id value, t.name label
FROM data.data_source t
WHERE t.name LIKE "LUCAS%"
--WHERE t.name LIKE "SearchValue" AND t.tenant_id = 1
ORDER BY t.name;
END $function$
*/
}
/**
* @function macrofauna_extraction_method_l
* @memberof zzgll
* @description Macrofauna extraction method l
* @param {character_varying} SearchValue
* @param {integer} Key
* @returns {Object} integer idcharacter_varying name
*/
function macrofauna_extraction_method_l() {
/*
CREATE OR REPLACE FUNCTION zzgll.macrofauna_extraction_method_l("SearchValue" character varying, "Key" integer DEFAULT NULL::integer)
RETURNS TABLE(id integer, name character varying)
LANGUAGE plpgsql
AS $function$
BEGIN
IF "Key" IS NOT NULL THEN
RETURN QUERY
SELECT t.id, t.name
FROM macrofauna.extraction_method t
WHERE t.id = "Key"::integer;
ELSE
RETURN QUERY
SELECT t.id, t.name
FROM macrofauna.extraction_method t
WHERE t.name LIKE "SearchValue"
ORDER BY t.name
LIMIT 1000;
END IF;
END $function$
*/
}
/**
* @function meta_data_type_l
* @memberof zzgll
* @description Meta data type l
* @param {character_varying} SearchValue
* @param {integer} Key
* @returns {Object}
* @property {integer} id
* @property {character_varying} name
*/
function meta_data_type_l() {
/*
CREATE OR REPLACE FUNCTION zzgll.meta_data_type_l("SearchValue" character varying, "Key" integer DEFAULT NULL::integer)
RETURNS TABLE(id integer, name character varying)
LANGUAGE plpgsql
AS $function$
BEGIN
IF "Key" IS NOT NULL THEN
RETURN QUERY
SELECT t.id, t.name
FROM meta.data_type t
WHERE t.id = "Key"::integer;
ELSE
RETURN QUERY
SELECT t.id, t.name
FROM meta.data_type t
WHERE t.name LIKE "SearchValue"
ORDER BY t.name
LIMIT 1000;
END IF;
END $function$
*/
}
/**
* @function meta_help_l
* @memberof zzgll
* @description Meta help l
* @param {character_varying} SearchValue
* @param {integer} Key
* @returns {Object}
* @property {integer} id
* @property {character_varying} name
*/
function meta_help_l() {
/*
CREATE OR REPLACE FUNCTION zzgll.meta_help_l("SearchValue" character varying, "Key" integer DEFAULT NULL::integer)
RETURNS TABLE(id integer, name character varying)
LANGUAGE plpgsql
AS $function$
BEGIN
IF "Key" IS NOT NULL THEN
RETURN QUERY
SELECT t.id, t.name
FROM meta.help t
WHERE t.id = "Key"::integer;
ELSE
RETURN QUERY
SELECT t.id, t.name
FROM meta.help t
WHERE t.name LIKE "SearchValue"
ORDER BY t.name
LIMIT 1000;
END IF;
END $function$
*/
}
/**
* @function meta_i18n_l
* @memberof zzgll
* @description Meta i18n l
* @param {character_varying} SearchValue
* @param {integer} Key
* @returns {Object}
* @property {integer} id
* @property {character_varying} key
*/
function meta_i18n_l() {
/*
CREATE OR REPLACE FUNCTION zzgll.meta_i18n_l("SearchValue" character varying, "Key" integer DEFAULT NULL::integer)
RETURNS TABLE(id integer, key character varying)
LANGUAGE plpgsql
AS $function$
BEGIN
IF "Key" IS NOT NULL THEN
RETURN QUERY
SELECT t.id, t.key
FROM meta.i18n t
WHERE t.id = "Key"::integer;
ELSE
RETURN QUERY
SELECT t.id, t.key
FROM meta.i18n t
WHERE t.key LIKE "SearchValue"
ORDER BY t.key
LIMIT 1000;
END IF;
END $function$
*/
}
/**
* @function meta_import_master_l
* @memberof zzgll
* @description Meta import master l
* @param {character_varying} SearchValue
* @param {integer} Key
* @returns {Object} integer idcharacter_varying schema_name
*/
function meta_import_master_l() {
/*
CREATE OR REPLACE FUNCTION zzgll.meta_import_master_l("SearchValue" character varying, "Key" integer DEFAULT NULL::integer)
RETURNS TABLE(id integer, schema_name character varying)
LANGUAGE plpgsql
AS $function$
BEGIN
IF "Key" IS NOT NULL THEN
RETURN QUERY
SELECT t.id, t.schema_name
FROM meta.import_master t
WHERE t.id = "Key"::integer;
ELSE
RETURN QUERY
SELECT t.id, t.schema_name
FROM meta.import_master t
WHERE t.schema_name LIKE "SearchValue"
ORDER BY t.schema_name
LIMIT 1000;
END IF;
END $function$
*/
}
/**
* @function meta_lang_l
* @memberof zzgll
* @description Meta lang l
* @param {character_varying} SearchValue
* @param {integer} Key
* @returns {Object}
* @property {integer} id
* @property {character_varying} name
*/
function meta_lang_l() {
/*
CREATE OR REPLACE FUNCTION zzgll.meta_lang_l("SearchValue" character varying, "Key" integer DEFAULT NULL::integer)
RETURNS TABLE(id integer, name character varying)
LANGUAGE plpgsql
AS $function$
BEGIN
IF "Key" IS NOT NULL THEN
RETURN QUERY
SELECT t.id, t.name
FROM meta.lang t
WHERE t.id = "Key"::integer;
ELSE
RETURN QUERY
SELECT t.id, t.name
FROM meta.lang t
WHERE t.name LIKE "SearchValue"
ORDER BY t.name
LIMIT 1000;
END IF;
END $function$
*/
}
/**
* @function meta_news_l
* @memberof zzgll
* @description Meta news l
* @param {character_varying} SearchValue
* @param {integer} Key
* @returns {Object}
* @property {integer} id
* @property {character_varying} name
*/
function meta_news_l() {
/*
CREATE OR REPLACE FUNCTION zzgll.meta_news_l("SearchValue" character varying, "Key" integer DEFAULT NULL::integer)
RETURNS TABLE(id integer, name character varying)
LANGUAGE plpgsql
AS $function$
BEGIN
IF "Key" IS NOT NULL THEN
RETURN QUERY
SELECT t.id, t.name
FROM meta.news t
WHERE t.id = "Key"::integer;
ELSE
RETURN QUERY
SELECT t.id, t.name
FROM meta.news t
WHERE t.name LIKE "SearchValue"
ORDER BY t.name
LIMIT 1000;
END IF;
END $function$
*/
}
/**
* @function meta_route_l
* @memberof zzgll
* @description Meta route l
* @param {character_varying} SearchValue
* @param {integer} Key
* @returns {Object} integer idcharacter_varying name
*/
function meta_route_l() {
/*
CREATE OR REPLACE FUNCTION zzgll.meta_route_l("SearchValue" character varying, "Key" integer DEFAULT NULL::integer)
RETURNS TABLE(id integer, name character varying)
LANGUAGE plpgsql
AS $function$
BEGIN
IF "Key" IS NOT NULL THEN
RETURN QUERY
SELECT t.id, t.name
FROM meta.route t
WHERE t.id = "Key"::integer;
ELSE
RETURN QUERY
SELECT t.id, t.name
FROM meta.route t
WHERE t.name LIKE "SearchValue"
ORDER BY t.name
LIMIT 1000;
END IF;
END $function$
*/
}