Extremely Popular
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822823824825826827828829830831832833834835836837838839840841842843844845846847848849850851852853854855856857858859860861862863864865866867868869870871872873874875876877878879880881882883884885886887888889890891892893894895896897898899900901902903904905906907import { assertEquals, decodeBase64, encodeBase64, formatDate, parseDate,} from "../test_deps.ts";import { Client } from "../mod.ts";import TEST_CONNECTION_PARAMS from "./config.ts";import { getTestClient } from "./helpers.ts";import { Box, Circle, Float4, Float8, Line, LineSegment, Path, Point, Polygon, TID, Timestamp,} from "../query/types.ts";
const SETUP = [ "DROP TABLE IF EXISTS data_types;", `CREATE TABLE data_types( inet_t inet, macaddr_t macaddr, cidr_t cidr );`,];
/** * This will generate a random number with a precision of 2 */// deno-lint-ignore camelcasefunction generateRandomNumber(max_value: number) { return Math.round((Math.random() * max_value + Number.EPSILON) * 100) / 100;}
// deno-lint-ignore camelcasefunction generateRandomPoint(max_value = 100): Point { return { x: String(generateRandomNumber(max_value)) as Float8, y: String(generateRandomNumber(max_value)) as Float8, };}
const CLIENT = new Client(TEST_CONNECTION_PARAMS);
const testClient = getTestClient(CLIENT, SETUP);
testClient(async function inet() { const inet = "127.0.0.1"; await CLIENT.queryArray( "INSERT INTO data_types (inet_t) VALUES($1)", inet, ); const selectRes = await CLIENT.queryArray( "SELECT inet_t FROM data_types WHERE inet_t=$1", inet, ); assertEquals(selectRes.rows[0][0], inet);});
testClient(async function inetArray() { const selectRes = await CLIENT.queryArray( "SELECT '{ 127.0.0.1, 192.168.178.0/24 }'::inet[]", ); assertEquals(selectRes.rows[0], [["127.0.0.1", "192.168.178.0/24"]]);});
testClient(async function inetNestedArray() { const selectRes = await CLIENT.queryArray( "SELECT '{{127.0.0.1},{192.168.178.0/24}}'::inet[]", ); assertEquals(selectRes.rows[0], [[["127.0.0.1"], ["192.168.178.0/24"]]]);});
testClient(async function macaddr() { const macaddr = "08:00:2b:01:02:03"; await CLIENT.queryArray( "INSERT INTO data_types (macaddr_t) VALUES($1)", macaddr, ); const selectRes = await CLIENT.queryArray( "SELECT macaddr_t FROM data_types WHERE macaddr_t=$1", macaddr, ); assertEquals(selectRes.rows, [[macaddr]]);});
testClient(async function macaddrArray() { const selectRes = await CLIENT.queryArray( "SELECT '{ 08:00:2b:01:02:03, 09:00:2b:01:02:04 }'::macaddr[]", ); assertEquals(selectRes.rows[0], [["08:00:2b:01:02:03", "09:00:2b:01:02:04"]]);});
testClient(async function macaddrNestedArray() { const selectRes = await CLIENT.queryArray( "SELECT '{{08:00:2b:01:02:03},{09:00:2b:01:02:04}}'::macaddr[]", ); assertEquals( selectRes.rows[0], [[["08:00:2b:01:02:03"], ["09:00:2b:01:02:04"]]], );});
testClient(async function cidr() { const cidr = "192.168.100.128/25"; await CLIENT.queryArray( "INSERT INTO data_types (cidr_t) VALUES($1)", cidr, ); const selectRes = await CLIENT.queryArray( "SELECT cidr_t FROM data_types WHERE cidr_t=$1", cidr, ); assertEquals(selectRes.rows, [[cidr]]);});
testClient(async function cidrArray() { const selectRes = await CLIENT.queryArray( "SELECT '{ 10.1.0.0/16, 11.11.11.0/24 }'::cidr[]", ); assertEquals(selectRes.rows[0], [["10.1.0.0/16", "11.11.11.0/24"]]);});
testClient(async function cidrNestedArray() { const selectRes = await CLIENT.queryArray( "SELECT '{{10.1.0.0/16},{11.11.11.0/24}}'::cidr[]", ); assertEquals(selectRes.rows[0], [[["10.1.0.0/16"], ["11.11.11.0/24"]]]);});
testClient(async function name() { const result = await CLIENT.queryArray(`SELECT 'some'::name`); assertEquals(result.rows[0][0], "some");});
testClient(async function nameArray() { const result = await CLIENT.queryArray(`SELECT ARRAY['some'::name, 'none']`); assertEquals(result.rows[0][0], ["some", "none"]);});
testClient(async function oid() { const result = await CLIENT.queryArray(`SELECT 1::oid`); assertEquals(result.rows[0][0], "1");});
testClient(async function oidArray() { const result = await CLIENT.queryArray(`SELECT ARRAY[1::oid, 452, 1023]`); assertEquals(result.rows[0][0], ["1", "452", "1023"]);});
testClient(async function regproc() { const result = await CLIENT.queryArray(`SELECT 'now'::regproc`); assertEquals(result.rows[0][0], "now");});
testClient(async function regprocArray() { const result = await CLIENT.queryArray( `SELECT ARRAY['now'::regproc, 'timeofday']`, ); assertEquals(result.rows[0][0], ["now", "timeofday"]);});
testClient(async function regprocedure() { const result = await CLIENT.queryArray(`SELECT 'sum(integer)'::regprocedure`); assertEquals(result.rows[0][0], "sum(integer)");});
testClient(async function regprocedureArray() { const result = await CLIENT.queryArray( `SELECT ARRAY['sum(integer)'::regprocedure, 'max(integer)']`, ); assertEquals(result.rows[0][0], ["sum(integer)", "max(integer)"]);});
testClient(async function regoper() { const result = await CLIENT.queryArray(`SELECT '!'::regoper`); assertEquals(result.rows[0][0], "!");});
testClient(async function regoperArray() { const result = await CLIENT.queryArray(`SELECT ARRAY['!'::regoper]`); assertEquals(result.rows[0][0], ["!"]);});
testClient(async function regoperator() { const result = await CLIENT.queryArray( `SELECT '!(bigint,NONE)'::regoperator`, ); assertEquals(result.rows[0][0], "!(bigint,NONE)");});
testClient(async function regoperatorArray() { const result = await CLIENT.queryArray( `SELECT ARRAY['!(bigint,NONE)'::regoperator, '*(integer,integer)']`, ); assertEquals(result.rows[0][0], ["!(bigint,NONE)", "*(integer,integer)"]);});
testClient(async function regclass() { const result = await CLIENT.queryArray(`SELECT 'data_types'::regclass`); assertEquals(result.rows, [["data_types"]]);});
testClient(async function regclassArray() { const result = await CLIENT.queryArray( `SELECT ARRAY['data_types'::regclass, 'pg_type']`, ); assertEquals(result.rows[0][0], ["data_types", "pg_type"]);});
testClient(async function regtype() { const result = await CLIENT.queryArray(`SELECT 'integer'::regtype`); assertEquals(result.rows[0][0], "integer");});
testClient(async function regtypeArray() { const result = await CLIENT.queryArray( `SELECT ARRAY['integer'::regtype, 'bigint']`, ); assertEquals(result.rows[0][0], ["integer", "bigint"]);});
// This test assumes that if the user wasn't provided through// the config file, it will be available in the env configtestClient(async function regrole() { const user = TEST_CONNECTION_PARAMS.user || Deno.env.get("PGUSER");
const result = await CLIENT.queryArray( `SELECT ($1)::regrole`, user, );
assertEquals(result.rows[0][0], user);});
// This test assumes that if the user wasn't provided through// the config file, it will be available in the env configtestClient(async function regroleArray() { const user = TEST_CONNECTION_PARAMS.user || Deno.env.get("PGUSER");
const result = await CLIENT.queryArray( `SELECT ARRAY[($1)::regrole]`, user, );
assertEquals(result.rows[0][0], [user]);});
testClient(async function regnamespace() { const result = await CLIENT.queryArray(`SELECT 'public'::regnamespace;`); assertEquals(result.rows[0][0], "public");});
testClient(async function regnamespaceArray() { const result = await CLIENT.queryArray( `SELECT ARRAY['public'::regnamespace, 'pg_catalog'];`, ); assertEquals(result.rows[0][0], ["public", "pg_catalog"]);});
testClient(async function regconfig() { const result = await CLIENT.queryArray(`SElECT 'english'::regconfig`); assertEquals(result.rows, [["english"]]);});
testClient(async function regconfigArray() { const result = await CLIENT.queryArray( `SElECT ARRAY['english'::regconfig, 'spanish']`, ); assertEquals(result.rows[0][0], ["english", "spanish"]);});
testClient(async function regdictionary() { const result = await CLIENT.queryArray("SELECT 'simple'::regdictionary"); assertEquals(result.rows[0][0], "simple");});
testClient(async function regdictionaryArray() { const result = await CLIENT.queryArray( "SELECT ARRAY['simple'::regdictionary]", ); assertEquals(result.rows[0][0], ["simple"]);});
testClient(async function bigint() { const result = await CLIENT.queryArray("SELECT 9223372036854775807"); assertEquals(result.rows[0][0], 9223372036854775807n);});
testClient(async function bigintArray() { const result = await CLIENT.queryArray( "SELECT ARRAY[9223372036854775807, 789141]", ); assertEquals(result.rows[0][0], [9223372036854775807n, 789141n]);});
testClient(async function numeric() { const numeric = "1234567890.1234567890"; const result = await CLIENT.queryArray(`SELECT $1::numeric`, numeric); assertEquals(result.rows, [[numeric]]);});
testClient(async function numericArray() { const numeric = ["1234567890.1234567890", "6107693.123123124"]; const result = await CLIENT.queryArray( `SELECT ARRAY[$1::numeric, $2]`, numeric[0], numeric[1], ); assertEquals(result.rows[0][0], numeric);});
testClient(async function integerArray() { const result = await CLIENT.queryArray("SELECT '{1,100}'::int[]"); assertEquals(result.rows[0], [[1, 100]]);});
testClient(async function integerNestedArray() { const result = await CLIENT.queryArray("SELECT '{{1},{100}}'::int[]"); assertEquals(result.rows[0], [[[1], [100]]]);});
testClient(async function char() { await CLIENT.queryArray( `CREATE TEMP TABLE CHAR_TEST (X CHARACTER(2));`, ); await CLIENT.queryArray( `INSERT INTO CHAR_TEST (X) VALUES ('A');`, ); const result = await CLIENT.queryArray( `SELECT X FROM CHAR_TEST`, ); assertEquals(result.rows[0][0], "A ");});
testClient(async function charArray() { const result = await CLIENT.queryArray( `SELECT '{"x","Y"}'::char[]`, ); assertEquals(result.rows[0][0], ["x", "Y"]);});
testClient(async function text() { const result = await CLIENT.queryArray( `SELECT 'ABCD'::text`, ); assertEquals(result.rows[0][0], "ABCD");});
testClient(async function textArray() { const result = await CLIENT.queryArray( `SELECT '{"(ZYX)-123-456","(ABC)-987-654"}'::text[]`, ); assertEquals(result.rows[0], [["(ZYX)-123-456", "(ABC)-987-654"]]);});
testClient(async function textNestedArray() { const result = await CLIENT.queryArray( `SELECT '{{"(ZYX)-123-456"},{"(ABC)-987-654"}}'::text[]`, ); assertEquals(result.rows[0], [[["(ZYX)-123-456"], ["(ABC)-987-654"]]]);});
testClient(async function varchar() { const result = await CLIENT.queryArray( `SELECT 'ABC'::varchar`, ); assertEquals(result.rows[0][0], "ABC");});
testClient(async function varcharArray() { const result = await CLIENT.queryArray( `SELECT '{"(ZYX)-(PQR)-456","(ABC)-987-(?=+)"}'::varchar[]`, ); assertEquals(result.rows[0], [["(ZYX)-(PQR)-456", "(ABC)-987-(?=+)"]]);});
testClient(async function varcharNestedArray() { const result = await CLIENT.queryArray( `SELECT '{{"(ZYX)-(PQR)-456"},{"(ABC)-987-(?=+)"}}'::varchar[]`, ); assertEquals(result.rows[0], [[["(ZYX)-(PQR)-456"], ["(ABC)-987-(?=+)"]]]);});
testClient(async function uuid() { const uuid = "c4792ecb-c00a-43a2-bd74-5b0ed551c599"; const result = await CLIENT.queryArray(`SELECT $1::uuid`, uuid); assertEquals(result.rows, [[uuid]]);});
testClient(async function uuidArray() { const result = await CLIENT.queryArray( `SELECT '{"c4792ecb-c00a-43a2-bd74-5b0ed551c599", "c9dd159e-d3d7-4bdf-b0ea-e51831c28e9b"}'::uuid[]`, ); assertEquals( result.rows[0], [[ "c4792ecb-c00a-43a2-bd74-5b0ed551c599", "c9dd159e-d3d7-4bdf-b0ea-e51831c28e9b", ]], );});
testClient(async function uuidNestedArray() { const result = await CLIENT.queryArray( `SELECT '{{"c4792ecb-c00a-43a2-bd74-5b0ed551c599"}, {"c9dd159e-d3d7-4bdf-b0ea-e51831c28e9b"}}'::uuid[]`, ); assertEquals( result.rows[0], [[ ["c4792ecb-c00a-43a2-bd74-5b0ed551c599"], ["c9dd159e-d3d7-4bdf-b0ea-e51831c28e9b"], ]], );});
testClient(async function voidType() { const result = await CLIENT.queryArray("select pg_sleep(0.01)"); // `pg_sleep()` returns void. assertEquals(result.rows, [[""]]);});
testClient(async function bpcharType() { const result = await CLIENT.queryArray( "SELECT cast('U7DV6WQ26D7X2IILX5L4LTYMZUKJ5F3CEDDQV3ZSLQVYNRPX2WUA' as char(52));", ); assertEquals( result.rows, [["U7DV6WQ26D7X2IILX5L4LTYMZUKJ5F3CEDDQV3ZSLQVYNRPX2WUA"]], );});
testClient(async function bpcharArray() { const result = await CLIENT.queryArray( `SELECT '{"AB1234","4321BA"}'::bpchar[]`, ); assertEquals(result.rows[0], [["AB1234", "4321BA"]]);});
testClient(async function bpcharNestedArray() { const result = await CLIENT.queryArray( `SELECT '{{"AB1234"},{"4321BA"}}'::bpchar[]`, ); assertEquals(result.rows[0], [[["AB1234"], ["4321BA"]]]);});
testClient(async function jsonArray() { const jsonArray = await CLIENT.queryArray( `SELECT ARRAY_AGG(A) FROM ( SELECT JSON_BUILD_OBJECT( 'X', '1' ) AS A UNION ALL SELECT JSON_BUILD_OBJECT( 'Y', '2' ) AS A ) A`, );
assertEquals(jsonArray.rows[0][0], [{ X: "1" }, { Y: "2" }]);
const jsonArrayNested = await CLIENT.queryArray( `SELECT ARRAY[ARRAY[ARRAY_AGG(A), ARRAY_AGG(A)], ARRAY[ARRAY_AGG(A), ARRAY_AGG(A)]] FROM ( SELECT JSON_BUILD_OBJECT( 'X', '1' ) AS A UNION ALL SELECT JSON_BUILD_OBJECT( 'Y', '2' ) AS A ) A`, );
assertEquals( jsonArrayNested.rows[0][0], [ [ [{ X: "1" }, { Y: "2" }], [{ X: "1" }, { Y: "2" }], ], [ [{ X: "1" }, { Y: "2" }], [{ X: "1" }, { Y: "2" }], ], ], );});
testClient(async function bool() { const result = await CLIENT.queryArray( `SELECT bool('y')`, ); assertEquals(result.rows[0][0], true);});
testClient(async function boolArray() { const result = await CLIENT.queryArray( `SELECT array[bool('y'), bool('n'), bool('1'), bool('0')]`, ); assertEquals(result.rows[0][0], [true, false, true, false]);});
const CHARS = "0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ";function randomBase64(): string { return encodeBase64( Array.from( { length: Math.ceil(Math.random() * 256) }, () => CHARS[Math.floor(Math.random() * CHARS.length)], ).join(""), );}
testClient(async function bytea() { const base64 = randomBase64();
const result = await CLIENT.queryArray( `SELECT decode('${base64}','base64')`, );
assertEquals(result.rows[0][0], decodeBase64(base64));});
testClient(async function byteaArray() { const strings = Array.from( { length: Math.ceil(Math.random() * 10) }, randomBase64, );
const result = await CLIENT.queryArray( `SELECT array[ ${ strings.map((x) => `decode('${x}', 'base64')`).join(", ") } ]`, );
assertEquals( result.rows[0][0], strings.map(decodeBase64), );});
testClient(async function point() { const selectRes = await CLIENT.queryArray<[Point]>( "SELECT point(1, 2.5)", ); assertEquals(selectRes.rows, [[{ x: "1", y: "2.5" }]]);});
testClient(async function pointArray() { const result1 = await CLIENT.queryArray( `SELECT '{"(1, 2)","(3.5, 4.1)"}'::point[]`, ); assertEquals(result1.rows, [ [[{ x: "1", y: "2" }, { x: "3.5", y: "4.1" }]], ]);
const result2 = await CLIENT.queryArray( `SELECT array[ array[ point(1,2), point(3.5, 4.1) ], array[ point(25, 50), point(-10, -17.5) ] ]`, ); assertEquals(result2.rows[0], [ [ [{ x: "1", y: "2" }, { x: "3.5", y: "4.1" }], [{ x: "25", y: "50" }, { x: "-10", y: "-17.5" }], ], ]);});
testClient(async function time() { const result = await CLIENT.queryArray("SELECT '01:01:01'::TIME");
assertEquals(result.rows[0][0], "01:01:01");});
testClient(async function timeArray() { const result = await CLIENT.queryArray("SELECT ARRAY['01:01:01'::TIME]");
assertEquals(result.rows[0][0], ["01:01:01"]);});
testClient(async function timestamp() { const timestamp = "1999-01-08 04:05:06"; const result = await CLIENT.queryArray<[Timestamp]>( `SELECT $1::TIMESTAMP, 'INFINITY'::TIMESTAMP`, timestamp, );
assertEquals(result.rows[0], [new Date(timestamp), Infinity]);});
testClient(async function timestampArray() { const timestamps = [ "2011-10-05T14:48:00.00", new Date().toISOString().slice(0, -1), ];
const result = await CLIENT.queryArray<[[Timestamp, Timestamp]]>( `SELECT ARRAY[$1::TIMESTAMP, $2]`, ...timestamps, );
assertEquals(result.rows[0][0], timestamps.map((x) => new Date(x)));});
testClient(async function timestamptz() { const timestamp = "1999-01-08 04:05:06+02"; const result = await CLIENT.queryArray<[Timestamp]>( `SELECT $1::TIMESTAMPTZ, 'INFINITY'::TIMESTAMPTZ`, timestamp, );
assertEquals(result.rows[0], [new Date(timestamp), Infinity]);});
const timezone = new Date().toTimeString().slice(12, 17);
testClient(async function timestamptzArray() { const timestamps = [ "2012/04/10 10:10:30 +0000", new Date().toISOString(), ];
const result = await CLIENT.queryArray<[[Timestamp, Timestamp]]>( `SELECT ARRAY[$1::TIMESTAMPTZ, $2]`, ...timestamps, );
assertEquals(result.rows[0][0], [ new Date(timestamps[0]), new Date(timestamps[1]), ]);});
testClient(async function timetz() { const result = await CLIENT.queryArray<[string]>( `SELECT '01:01:01${timezone}'::TIMETZ`, );
assertEquals(result.rows[0][0].slice(0, 8), "01:01:01");});
testClient(async function timetzArray() { const result = await CLIENT.queryArray<[string]>( `SELECT ARRAY['01:01:01${timezone}'::TIMETZ]`, );
assertEquals(typeof result.rows[0][0][0], "string");
assertEquals(result.rows[0][0][0].slice(0, 8), "01:01:01");});
testClient(async function xid() { const result = await CLIENT.queryArray("SELECT '1'::xid");
assertEquals(result.rows[0][0], 1);});
testClient(async function xidArray() { const result = await CLIENT.queryArray( "SELECT ARRAY['12'::xid, '4789'::xid]", );
assertEquals(result.rows[0][0], [12, 4789]);});
testClient(async function float4() { const result = await CLIENT.queryArray<[Float4, Float4]>( "SELECT '1'::FLOAT4, '17.89'::FLOAT4", );
assertEquals(result.rows[0], ["1", "17.89"]);});
testClient(async function float4Array() { const result = await CLIENT.queryArray<[[Float4, Float4]]>( "SELECT ARRAY['12.25'::FLOAT4, '4789']", );
assertEquals(result.rows[0][0], ["12.25", "4789"]);});
testClient(async function float8() { const result = await CLIENT.queryArray<[Float8, Float8]>( "SELECT '1'::FLOAT8, '17.89'::FLOAT8", );
assertEquals(result.rows[0], ["1", "17.89"]);});
testClient(async function float8Array() { const result = await CLIENT.queryArray<[[Float8, Float8]]>( "SELECT ARRAY['12.25'::FLOAT8, '4789']", );
assertEquals(result.rows[0][0], ["12.25", "4789"]);});
testClient(async function tid() { const result = await CLIENT.queryArray<[TID, TID]>( "SELECT '(1, 19)'::TID, '(23, 17)'::TID", );
assertEquals(result.rows[0], [[1n, 19n], [23n, 17n]]);});
testClient(async function tidArray() { const result = await CLIENT.queryArray<[[TID, TID]]>( "SELECT ARRAY['(4681, 1869)'::TID, '(0, 17476)']", );
assertEquals(result.rows[0][0], [[4681n, 1869n], [0n, 17476n]]);});
testClient(async function date() { const date = "2020-01-01";
const result = await CLIENT.queryArray<[Timestamp, Timestamp]>( "SELECT $1::DATE, 'Infinity'::Date", date, );
assertEquals(result.rows[0], [parseDate(date, "yyyy-MM-dd"), Infinity]);});
testClient(async function dateArray() { const dates = ["2020-01-01", formatDate(new Date(), "yyyy-MM-dd")];
const result = await CLIENT.queryArray<[Timestamp, Timestamp]>( "SELECT ARRAY[$1::DATE, $2]", ...dates, );
assertEquals( result.rows[0][0], dates.map((date) => parseDate(date, "yyyy-MM-dd")), );});
testClient(async function line() { const result = await CLIENT.queryArray<[Line]>( "SELECT '[(1, 2), (3, 4)]'::LINE", );
assertEquals(result.rows[0][0], { a: "1", b: "-1", c: "1" });});
testClient(async function lineArray() { const result = await CLIENT.queryArray<[[Line, Line]]>( "SELECT ARRAY['[(1, 2), (3, 4)]'::LINE, '41, 1, -9, 25.5']", );
assertEquals(result.rows[0][0], [ { a: "1", b: "-1", c: "1" }, { a: "-0.49", b: "-1", c: "21.09", }, ]);});
testClient(async function lineSegment() { const result = await CLIENT.queryArray<[LineSegment]>( "SELECT '[(1, 2), (3, 4)]'::LSEG", );
assertEquals(result.rows[0][0], { a: { x: "1", y: "2" }, b: { x: "3", y: "4" }, });});
testClient(async function lineSegmentArray() { const result = await CLIENT.queryArray<[[LineSegment, LineSegment]]>( "SELECT ARRAY['[(1, 2), (3, 4)]'::LSEG, '41, 1, -9, 25.5']", );
assertEquals(result.rows[0][0], [ { a: { x: "1", y: "2" }, b: { x: "3", y: "4" }, }, { a: { x: "41", y: "1" }, b: { x: "-9", y: "25.5" }, }, ]);});
testClient(async function box() { const result = await CLIENT.queryArray<[Box]>( "SELECT '((1, 2), (3, 4))'::BOX", );
assertEquals(result.rows[0][0], { a: { x: "3", y: "4" }, b: { x: "1", y: "2" }, });});
testClient(async function boxArray() { const result = await CLIENT.queryArray<[[Box, Box]]>( "SELECT ARRAY['(1, 2), (3, 4)'::BOX, '41, 1, -9, 25.5']", );
assertEquals(result.rows[0][0], [ { a: { x: "3", y: "4" }, b: { x: "1", y: "2" }, }, { a: { x: "41", y: "25.5" }, b: { x: "-9", y: "1" }, }, ]);});
testClient(async function path() { const points = Array.from( { length: Math.floor((Math.random() + 1) * 10) }, generateRandomPoint, );
const selectRes = await CLIENT.queryArray<[Path]>( `SELECT '(${points.map(({ x, y }) => `(${x},${y})`).join(",")})'::PATH`, );
assertEquals(selectRes.rows[0][0], points);});
testClient(async function pathArray() { const points = Array.from( { length: Math.floor((Math.random() + 1) * 10) }, generateRandomPoint, );
const selectRes = await CLIENT.queryArray<[[Path]]>( `SELECT ARRAY['(${ points.map(({ x, y }) => `(${x},${y})`).join(",") })'::PATH]`, );
assertEquals(selectRes.rows[0][0][0], points);});
testClient(async function polygon() { const points = Array.from( { length: Math.floor((Math.random() + 1) * 10) }, generateRandomPoint, );
const selectRes = await CLIENT.queryArray<[Polygon]>( `SELECT '(${points.map(({ x, y }) => `(${x},${y})`).join(",")})'::POLYGON`, );
assertEquals(selectRes.rows[0][0], points);});
testClient(async function polygonArray() { const points = Array.from( { length: Math.floor((Math.random() + 1) * 10) }, generateRandomPoint, );
const selectRes = await CLIENT.queryArray<[[Polygon]]>( `SELECT ARRAY['(${ points.map(({ x, y }) => `(${x},${y})`).join(",") })'::POLYGON]`, );
assertEquals(selectRes.rows[0][0][0], points);});
testClient(async function circle() { const point = generateRandomPoint(); const radius = String(generateRandomNumber(100));
const { rows } = await CLIENT.queryArray<[Circle]>( `SELECT '<(${point.x},${point.y}), ${radius}>'::CIRCLE`, );
assertEquals(rows[0][0], { point, radius });});
testClient(async function circleArray() { const point = generateRandomPoint(); const radius = String(generateRandomNumber(100));
const { rows } = await CLIENT.queryArray<[[Circle]]>( `SELECT ARRAY['<(${point.x},${point.y}), ${radius}>'::CIRCLE]`, );
assertEquals(rows[0][0][0], { point, radius });});
testClient(async function unhandledType() { const { rows: exists } = await CLIENT.queryArray( "SELECT EXISTS (SELECT TRUE FROM PG_TYPE WHERE UPPER(TYPNAME) = 'DIRECTION')", ); if (exists[0][0]) { await CLIENT.queryArray("DROP TYPE DIRECTION;"); } await CLIENT.queryArray("CREATE TYPE DIRECTION AS ENUM ( 'LEFT', 'RIGHT' )"); const { rows: result } = await CLIENT.queryArray("SELECT 'LEFT'::DIRECTION;"); await CLIENT.queryArray("DROP TYPE DIRECTION;");
assertEquals(result[0][0], "LEFT");});