parsav  Diff

		params = {uint64}, sql = [[
			select domain, key, knownsince, parsav from parsav_servers
				where id = $1::bigint
		]];
	};

	conf_get = {
		params = {rawstring}, sql = [[
			select value from parsav_config
				where key = $1::text limit 1
		]];
	};

	conf_set = {
		params = {rawstring,rawstring}, cmd=true, sql = [[
			insert into parsav_config (key, value)
				values ($1::text, $2::text)
				on conflict (key) do update set value = $2::text
		]];
	};

	conf_reset = {
................................................................................
		params = {uint64,uint64}, sql = [[
			select name, id, owner, array_length(members,1) from parsav_circles where
				($1::bigint = 0 or $1::bigint = owner) and
				($2::bigint = 0 or $2::bigint = id)
		]];
	};

















	circle_members_fetch_cid = {
		params = {uint64, uint64}, sql = [[








			select unnest(members) from parsav_circles where
				($1::bigint = 0 or owner = $1::bigint) and
				id = $2::bigint
		]];
	};

	circle_members_fetch_name = {
		params = {uint64, pstring}, sql = [[
			select unnest(members) from parsav_circles where
				($1::bigint = 0 or owner = $1::bigint) and
				name = $2::text
		]];
................................................................................
			order by c.tltime desc

			limit case when $3::bigint = 0 then null
					   else $3::bigint end
			offset $4::bigint
		]];
	};























	timeline_actor_fetch = {
		params = {uint64, uint64, uint64, uint64, uint64}, sql = [[
			with followed as (
				select relatee from parsav_rels where
					kind = <rel:follow> and
					relator = $1::bigint
			), avoided as (
				select relatee as avoidee from parsav_rels where
					kind = <rel:avoid> or kind = <rel:mute> and
					relator = $1::bigint
				union select relator as avoidee from parsav_rels where
					kind = <rel:exclude> and
					relatee = $1::bigint
			)
................................................................................
			select (c.post).*
			from pg_temp.parsavpg_known_content as c

			where ($2::bigint = 0 or c.tltime   <= $2::bigint) and
				  ($3::bigint = 0 or $3::bigint <  c.tltime) and
				  (c.promoter in (table followed) or
				   c.promoter = $1::bigint) and
				  not ((c.post).author in (table avoided))

			order by c.tltime desc

			limit case when $4::bigint = 0 then null
					   else $4::bigint end
			offset $5::bigint
		]];
	};
................................................................................
				artifacts = array_remove(artifacts, $2::bigint)
			where id = $1::bigint and
				artifacts @> array[$2::bigint]
		]];
	};

	actor_conf_str_get = {
		params = {uint64, rawstring}, sql = [[
			select value from parsav_actor_conf_strs where
				uid = $1::bigint and
				key = $2::text
			limit 1
		]];
	};
	actor_conf_str_set = {
		params = {uint64, rawstring, rawstring}, cmd = true, sql = [[
			insert into parsav_actor_conf_strs (uid,key,value)
				values ($1::bigint, $2::text, $3::text)
			on conflict (uid,key) do update set value = $3::text
		]];
	};
	actor_conf_str_enum = {
		params = {uint64}, sql = [[
			select value from parsav_actor_conf_strs where uid = $1::bigint
		]];
	};
	actor_conf_str_reset = {
		params = {uint64, rawstring}, cmd = true, sql = [[
			delete from parsav_actor_conf_strs where
				uid = $1::bigint and ($2::text is null or key = $2::text)
		]]
	};

	actor_conf_int_get = {
		params = {uint64, rawstring}, sql = [[
			select value from parsav_actor_conf_ints where
				uid = $1::bigint and
				key = $2::text
			limit 1
		]];
	};
	actor_conf_int_set = {
		params = {uint64, rawstring, uint64}, cmd = true, sql = [[
			insert into parsav_actor_conf_ints (uid,key,value)
				values ($1::bigint, $2::text, $3::bigint)
			on conflict (uid,key) do update set value = $3::bigint
		]];
	};
	actor_conf_int_enum = {
		params = {uint64}, sql = [[
			select value from parsav_actor_conf_ints where uid = $1::bigint
		]];
	};
	actor_conf_int_reset = {
		params = {uint64, rawstring}, cmd = true, sql = [[
			delete from parsav_actor_conf_ints where
				uid = $1::bigint and ($2::text is null or key = $2::text)
		]]
	};
}

local struct pqr {
................................................................................
			return true
		else
			lib.warn('backend pgsql - failed to obliterate database: \n', lib.pq.PQresultErrorMessage(res))
			return false
		end
	end];

	conf_get = [terra(src: &lib.store.source, key: rawstring)
		var r = queries.conf_get.exec(src, key)
		if r.sz == 0 then return [lib.mem.ptr(int8)] { ptr = nil, ct = 0 } else
			defer r:free()
			return r:String(0,0)
		end
	end];
	conf_set = [terra(src: &lib.store.source, key: rawstring, val: rawstring)
		queries.conf_set.exec(src, key, val):free() end];
	conf_reset = [terra(src: &lib.store.source, key: rawstring)
		queries.conf_reset.exec(src, key):free() end];
	
	actor_fetch_uid = [terra(src: &lib.store.source, uid: uint64)
		var r = queries.actor_fetch_uid.exec(src, uid)
		if r.sz == 0 then
................................................................................
	timeline_instance_fetch = [terra(
		src: &lib.store.source,
		rg: lib.store.range
	): lib.mem.lstptr(lib.store.post)
		var r = pqr { sz = 0 }
		var A,B,C,D = rg:matrix() -- :/
		r = queries.timeline_instance_fetch.exec(src,A,B,C,D)


















		
		var ret: lib.mem.ptr(lib.mem.ptr(lib.store.post)) ret:init(r.sz)
		for i=0,r.sz do
			ret.ptr[i] = row_to_post(&r, i) -- MUST FREE ALL
			ret.ptr[i].ptr.source = src
		end

................................................................................
	auth_sigtime_user_alter = [terra(
		src: &lib.store.source,
		uid: uint64,
		time: lib.store.timepoint
	): {} queries.auth_sigtime_user_alter.exec(src, uid, time) end];

	actor_conf_str_enum = nil;
	actor_conf_str_get = [terra(src: &lib.store.source, uid: uint64, key: rawstring): pstring





			var r = queries.actor_conf_str_get.exec(src, uid, key)
			if r.sz > 0 then
				var ret = r:String(0,0)
				r:free()
				return ret
			else return pstring.null() end
		end];
	actor_conf_str_set = [terra(src: &lib.store.source, uid: uint64, key: rawstring, value: rawstring): {}
			queries.actor_conf_str_set.exec(src,uid,key,value) end];
	actor_conf_str_reset = [terra(src: &lib.store.source, uid: uint64, key: rawstring): {}
			queries.actor_conf_str_reset.exec(src,uid,key) end];

	actor_conf_int_enum = nil;
	actor_conf_int_get = [terra(src: &lib.store.source, uid: uint64, key: rawstring)
			var r = queries.actor_conf_int_get.exec(src, uid, key)
			if r.sz > 0 then
				var ret = r:int(uint64,0,0)
				r:free()
				return ret, true
			end
			return 0, false
		end];
	actor_conf_int_set = [terra(src: &lib.store.source, uid: uint64, key: rawstring, value: uint64): {}
			queries.actor_conf_int_set.exec(src,uid,key,value) end];
	actor_conf_int_reset = [terra(src: &lib.store.source, uid: uint64, key: rawstring): {}
			queries.actor_conf_int_reset.exec(src,uid,key) end];
	
	circle_search = [terra(
		src: &lib.store.source,
		pool:&lib.mem.pool,
		uid: uint64,
		cid: uint64
................................................................................
		if res.sz == 0 then return [lib.mem.ptr(lib.store.circle)].null() end
		defer res:free()

		var rt = pool:alloc(lib.store.circle, res.sz)
		for i = 0, res.sz do
			var name = res:_string(i,0)
			rt(i) = lib.store.circle {
				name = name:pdup(pool);
				cid = res:int(uint64,i,1);




































				owner = res:int(uint64,i,2);
				memcount = res:int(uint64,i,3);
			}
		end

		return rt
	end];

	circle_members_fetch_cid = [terra(
		src: &lib.store.source,
		pool:&lib.mem.pool,
		uid: uint64,
		cid: uint64
	): lib.mem.ptr(uint64)
		var res = queries.circle_members_fetch_cid.exec(src,uid,cid)
		if res.sz == 0 then return [lib.mem.ptr(uint64)].null() end
		defer res:free()

		var rt = pool:alloc(uint64, res.sz)
		for i = 0, res.sz do rt(i) = res:int(uint64,i,0) end

		return rt
	end];

	actor_auth_register_uid = nil; -- TODO better support non-view based auth
}

return b

		params = {uint64}, sql = [[
			select domain, key, knownsince, parsav from parsav_servers
				where id = $1::bigint
		]];
	};

	conf_get = {
		params = {pstring}, sql = [[
			select value from parsav_config
				where key = $1::text limit 1
		]];
	};

	conf_set = {
		params = {pstring,pstring}, cmd=true, sql = [[
			insert into parsav_config (key, value)
				values ($1::text, $2::text)
				on conflict (key) do update set value = $2::text
		]];
	};

	conf_reset = {
................................................................................
		params = {uint64,uint64}, sql = [[
			select name, id, owner, array_length(members,1) from parsav_circles where
				($1::bigint = 0 or $1::bigint = owner) and
				($2::bigint = 0 or $2::bigint = id)
		]];
	};

	circle_create = {
		params = {uint64,pstring}, sql = [[
			insert into parsav_circles (owner,name)
				values ($1::bigint, $2::text)
			returning id
		]];
	};

	circle_destroy = {
		params = {uint64,uint64}, cmd = true, sql = [[
			delete from parsav_circles where
				owner = $1::bigint and
				id = $2::bigint
		]];
	};

	circle_memberships_uid = {
		params = {uint64, uint64}, sql = [[
			select name, id, owner, array_length(members,1) from parsav_circles where
				owner   =  $1::bigint and
				members @> array[$2::bigint]
		]];
	};

	circle_members_fetch_cid = {
		params = {uint64}, sql = [[
			select unnest(members) from parsav_circles where

				id = $1::bigint
		]];
	};

	circle_members_fetch_name = {
		params = {uint64, pstring}, sql = [[
			select unnest(members) from parsav_circles where
				($1::bigint = 0 or owner = $1::bigint) and
				name = $2::text
		]];
................................................................................
			order by c.tltime desc

			limit case when $3::bigint = 0 then null
					   else $3::bigint end
			offset $4::bigint
		]];
	};

	timeline_circle_fetch = {
		params = {uint64, uint64, uint64, uint64, uint64}, sql = [[
			with circle as (
				select unnest(members) from parsav_circles where id = $1::bigint
			)

			select (c.post).*
			from pg_temp.parsavpg_known_content as c

			where ($2::bigint = 0 or c.tltime   <= $2::bigint) and
				  ($3::bigint = 0 or $3::bigint <  c.tltime) and
				  (c.promoter in (table circle) or
				   c.promoter = (select owner from parsav_circles where id = $1::bigint))

			order by c.tltime desc

			limit case when $4::bigint = 0 then null
					   else $4::bigint end
			offset $5::bigint
		]];
	};

	timeline_actor_fetch = {
		params = {uint64, uint64, uint64, uint64, uint64}, sql = [[
			with followed as (
				select relatee from parsav_rels where
					kind = <rel:follow> and
					relator = $1::bigint
			), avoided as ( -- not strictly necessary but lets us minimize how much data needs to be sent back to parsav for filtering
				select relatee as avoidee from parsav_rels where
					kind = <rel:avoid> or kind = <rel:mute> and
					relator = $1::bigint
				union select relator as avoidee from parsav_rels where
					kind = <rel:exclude> and
					relatee = $1::bigint
			)
................................................................................
			select (c.post).*
			from pg_temp.parsavpg_known_content as c

			where ($2::bigint = 0 or c.tltime   <= $2::bigint) and
				  ($3::bigint = 0 or $3::bigint <  c.tltime) and
				  (c.promoter in (table followed) or
				   c.promoter = $1::bigint) and
				  not ((c.post).author in (table avoided)) and
				  not (c.promoter      in (table avoided))
			order by c.tltime desc

			limit case when $4::bigint = 0 then null
					   else $4::bigint end
			offset $5::bigint
		]];
	};
................................................................................
				artifacts = array_remove(artifacts, $2::bigint)
			where id = $1::bigint and
				artifacts @> array[$2::bigint]
		]];
	};

	actor_conf_str_get = {
		params = {uint64, pstring}, sql = [[
			select value from parsav_actor_conf_strs where
				uid = $1::bigint and
				key = $2::text
			limit 1
		]];
	};
	actor_conf_str_set = {
		params = {uint64, pstring, pstring}, cmd = true, sql = [[
			insert into parsav_actor_conf_strs (uid,key,value)
				values ($1::bigint, $2::text, $3::text)
			on conflict (uid,key) do update set value = $3::text
		]];
	};
	actor_conf_str_enum = {
		params = {uint64}, sql = [[
			select value from parsav_actor_conf_strs where uid = $1::bigint
		]];
	};
	actor_conf_str_reset = {
		params = {uint64, pstring}, cmd = true, sql = [[
			delete from parsav_actor_conf_strs where
				uid = $1::bigint and ($2::text is null or key = $2::text)
		]]
	};

	actor_conf_int_get = {
		params = {uint64, pstring}, sql = [[
			select value from parsav_actor_conf_ints where
				uid = $1::bigint and
				key = $2::text
			limit 1
		]];
	};
	actor_conf_int_set = {
		params = {uint64, pstring, uint64}, cmd = true, sql = [[
			insert into parsav_actor_conf_ints (uid,key,value)
				values ($1::bigint, $2::text, $3::bigint)
			on conflict (uid,key) do update set value = $3::bigint
		]];
	};
	actor_conf_int_enum = {
		params = {uint64}, sql = [[
			select value from parsav_actor_conf_ints where uid = $1::bigint
		]];
	};
	actor_conf_int_reset = {
		params = {uint64, pstring}, cmd = true, sql = [[
			delete from parsav_actor_conf_ints where
				uid = $1::bigint and ($2::text is null or key = $2::text)
		]]
	};
}

local struct pqr {
................................................................................
			return true
		else
			lib.warn('backend pgsql - failed to obliterate database: \n', lib.pq.PQresultErrorMessage(res))
			return false
		end
	end];

	conf_get = [terra(src: &lib.store.source, key: pstring)
		var r = queries.conf_get.exec(src, key)
		if r.sz == 0 then return [lib.mem.ptr(int8)] { ptr = nil, ct = 0 } else
			defer r:free()
			return r:String(0,0)
		end
	end];
	conf_set = [terra(src: &lib.store.source, key: pstring, val: pstring)
		queries.conf_set.exec(src, key, val):free() end];
	conf_reset = [terra(src: &lib.store.source, key: rawstring)
		queries.conf_reset.exec(src, key):free() end];
	
	actor_fetch_uid = [terra(src: &lib.store.source, uid: uint64)
		var r = queries.actor_fetch_uid.exec(src, uid)
		if r.sz == 0 then
................................................................................
	timeline_instance_fetch = [terra(
		src: &lib.store.source,
		rg: lib.store.range
	): lib.mem.lstptr(lib.store.post)
		var r = pqr { sz = 0 }
		var A,B,C,D = rg:matrix() -- :/
		r = queries.timeline_instance_fetch.exec(src,A,B,C,D)
		
		var ret: lib.mem.ptr(lib.mem.ptr(lib.store.post)) ret:init(r.sz)
		for i=0,r.sz do
			ret.ptr[i] = row_to_post(&r, i) -- MUST FREE ALL
			ret.ptr[i].ptr.source = src
		end

		return ret
	end];

	timeline_circle_fetch = [terra(
		src: &lib.store.source,
		cid: uint64,
		rg: lib.store.range
	): lib.mem.lstptr(lib.store.post)
		var r = pqr { sz = 0 }
		var A,B,C,D = rg:matrix() -- :/
		r = queries.timeline_circle_fetch.exec(src,cid,A,B,C,D)
		
		var ret: lib.mem.ptr(lib.mem.ptr(lib.store.post)) ret:init(r.sz)
		for i=0,r.sz do
			ret.ptr[i] = row_to_post(&r, i) -- MUST FREE ALL
			ret.ptr[i].ptr.source = src
		end

................................................................................
	auth_sigtime_user_alter = [terra(
		src: &lib.store.source,
		uid: uint64,
		time: lib.store.timepoint
	): {} queries.auth_sigtime_user_alter.exec(src, uid, time) end];

	actor_conf_str_enum = nil;
	actor_conf_str_get = [terra(
		src: &lib.store.source,
		pool: &lib.mem.pool,
		uid: uint64,
		key: pstring
	): pstring
			var r = queries.actor_conf_str_get.exec(src, uid, key)
			if r.sz > 0 then


				return r:_string(0,0):pdup(pool)
			else return pstring.null() end
		end];
	actor_conf_str_set = [terra(src: &lib.store.source, uid: uint64, key: pstring, value: pstring): {}
			queries.actor_conf_str_set.exec(src,uid,key,value) end];
	actor_conf_str_reset = [terra(src: &lib.store.source, uid: uint64, key: pstring): {}
			queries.actor_conf_str_reset.exec(src,uid,key) end];

	actor_conf_int_enum = nil;
	actor_conf_int_get = [terra(src: &lib.store.source, uid: uint64, key: pstring)
			var r = queries.actor_conf_int_get.exec(src, uid, key)
			if r.sz > 0 then
				var ret = r:int(uint64,0,0)
				r:free()
				return ret, true
			end
			return 0, false
		end];
	actor_conf_int_set = [terra(src: &lib.store.source, uid: uint64, key: pstring, value: uint64): {}
			queries.actor_conf_int_set.exec(src,uid,key,value) end];
	actor_conf_int_reset = [terra(src: &lib.store.source, uid: uint64, key: pstring): {}
			queries.actor_conf_int_reset.exec(src,uid,key) end];
	
	circle_search = [terra(
		src: &lib.store.source,
		pool:&lib.mem.pool,
		uid: uint64,
		cid: uint64
................................................................................
		if res.sz == 0 then return [lib.mem.ptr(lib.store.circle)].null() end
		defer res:free()

		var rt = pool:alloc(lib.store.circle, res.sz)
		for i = 0, res.sz do
			var name = res:_string(i,0)
			rt(i) = lib.store.circle {
				name = name:pdup(pool);      cid = res:int(uint64,i,1);
				owner = res:int(uint64,i,2); memcount = res:int(uint64,i,3);
			}
		end

		return rt
	end];

	circle_create = [terra(
		src: &lib.store.source,
		owner: uint64,
		name: pstring
	): uint64
		var r = queries.circle_create.exec(src, owner, name)
		if r.sz > 0 then defer r:free() return r:int(uint64,0,0) end
		return 0
	end];

	circle_destroy = [terra(
		src: &lib.store.source,
		owner: uint64,
		cid: uint64
	): {} queries.circle_destroy.exec(src, owner, cid) end];

	circle_memberships_uid = [terra(
		src: &lib.store.source,
		pool:&lib.mem.pool,
		owner: uint64,
		subject: uint64
	): lib.mem.ptr(lib.store.circle)
		var res = queries.circle_memberships_uid.exec(src, owner, subject)
		if res.sz == 0 then return [lib.mem.ptr(lib.store.circle)].null() end
		defer res:free()

		var rt = pool:alloc(lib.store.circle, res.sz)
		for i = 0, res.sz do
			var name = res:_string(i,0)
			rt(i) = lib.store.circle {
				name = name:pdup(pool);      cid = res:int(uint64,i,1);
				owner = res:int(uint64,i,2); memcount = res:int(uint64,i,3);
			}
		end

		return rt
	end];

	circle_members_fetch_cid = [terra(
		src: &lib.store.source,
		pool:&lib.mem.pool,

		cid: uint64
	): lib.mem.ptr(uint64)
		var res = queries.circle_members_fetch_cid.exec(src,cid)
		if res.sz == 0 then return [lib.mem.ptr(uint64)].null() end
		defer res:free()

		var rt = pool:alloc(uint64, res.sz)
		for i = 0, res.sz do rt(i) = res:int(uint64,i,0) end

		return rt
	end];

	actor_auth_register_uid = nil; -- TODO better support non-view based auth
}

return b