pqb 0.7.0 → 0.7.2

package/src/sql/copy.ts

@@ -0,0 +1,59 @@
+import { ToSqlCtx } from './toSql';
+import { CopyQueryData } from './data';
+import { Query } from '../query';
+import { q } from './common';
+import { quote } from '../quote';
+import { pushWhereStatementSql } from './where';
+
+export const pushCopySql = (
+  ctx: ToSqlCtx,
+  model: Query,
+  query: CopyQueryData,
+  quotedAs?: string,
+) => {
+  const { sql } = ctx;
+  const { copy } = query;
+
+  const columns = copy.columns ? `(${copy.columns.map(q).join(', ')})` : '';
+
+  const target = 'from' in copy ? copy.from : copy.to;
+
+  sql.push(
+    `COPY ${q(model.table as string)}${columns} ${
+      'from' in copy ? 'FROM' : 'TO'
+    } ${
+      typeof target === 'string'
+        ? quote(target)
+        : `PROGRAM ${quote(target.program)}`
+    }`,
+  );
+
+  if (Object.keys(copy).length > (copy.columns ? 2 : 1)) {
+    const options: string[] = [];
+
+    if (copy.format) options.push(`FORMAT ${copy.format}`);
+    if (copy.freeze) options.push(`FREEZE ${copy.freeze}`);
+    if (copy.delimiter) options.push(`DELIMITER ${quote(copy.delimiter)}`);
+    if (copy.null) options.push(`NULL ${quote(copy.null)}`);
+    if (copy.header) options.push(`HEADER ${copy.header}`);
+    if (copy.quote) options.push(`QUOTE ${quote(copy.quote)}`);
+    if (copy.escape) options.push(`ESCAPE ${quote(copy.escape)}`);
+    if (copy.forceQuote)
+      options.push(
+        `FORCE_QUOTE ${
+          copy.forceQuote === '*'
+            ? '*'
+            : `(${copy.forceQuote.map(q).join(', ')})`
+        }`,
+      );
+    if (copy.forceNotNull)
+      options.push(`FORCE_NOT_NULL (${copy.forceNotNull.map(q).join(', ')})`);
+    if (copy.forceNull)
+      options.push(`FORCE_NULL (${copy.forceNull.map(q).join(', ')})`);
+    if (copy.encoding) options.push(`ENCODING ${quote(copy.encoding)}`);
+
+    sql.push(`WITH (${options.join(', ')})`);
+  }
+
+  pushWhereStatementSql(ctx, model, query, quotedAs);
+};

package/src/sql/data.ts

@@ -136,13 +136,41 @@ export type ColumnInfoQueryData = CommonQueryData & {
   column?: string;
 };
 
+export type CopyQueryData = CommonQueryData & {
+  type: 'copy';
+  copy: CopyOptions;
+};
+
+export type CopyOptions<Column = string> = {
+  columns?: Column[];
+  format?: 'text' | 'csv' | 'binary';
+  freeze?: boolean;
+  delimiter?: string;
+  null?: string;
+  header?: boolean | 'match';
+  quote?: string;
+  escape?: string;
+  forceQuote?: Column[] | '*';
+  forceNotNull?: Column[];
+  forceNull?: Column[];
+  encoding?: string;
+} & (
+  | {
+      from: string | { program: string };
+    }
+  | {
+      to: string | { program: string };
+    }
+);
+
 export type QueryData =
   | SelectQueryData
   | InsertQueryData
   | UpdateQueryData
   | DeleteQueryData
   | TruncateQueryData
-  | ColumnInfoQueryData;
+  | ColumnInfoQueryData
+  | CopyQueryData;
 
 export const cloneQueryArrays = (q: QueryData) => {
   if (q.with) q.with = q.with?.slice(0);

package/src/sql/toSql.ts

@@ -18,6 +18,7 @@ import { pushOrderBySql } from './orderBy';
 import { OnQueryBuilder, WhereQueryBuilder } from '../queryMethods';
 import { getRaw, isRaw } from '../common';
 import { QueryData } from './data';
+import { pushCopySql } from './copy';
 
 export type ToSqlCtx = {
   whereQueryBuilder: typeof WhereQueryBuilder;
@@ -91,6 +92,11 @@ export const makeSql = (
       pushDeleteSql(ctx, model, query, quotedAs);
       return { text: sql.join(' '), values };
     }
+
+    if (query.type === 'copy') {
+      pushCopySql(ctx, model, query, quotedAs);
+      return { text: sql.join(' '), values };
+    }
   }
 
   const quotedAs = model.table && q(query.as || model.table);

package/src/{test-utils.ts → test-utils/test-utils.ts}

@@ -1,15 +1,15 @@
-import { Query } from './query';
-import { createDb } from './db';
+import { Query } from '../query';
+import { createDb } from '../db';
 import {
   patchPgForTransactions,
   rollbackTransaction,
   startTransaction,
 } from 'pg-transactional-tests';
 import { Client } from 'pg';
-import { quote } from './quote';
-import { columnTypes } from './columnSchema';
-import { MaybeArray, toArray } from './utils';
-import { Adapter } from './adapter';
+import { quote } from '../quote';
+import { columnTypes } from '../columnSchema';
+import { MaybeArray, toArray } from '../utils';
+import { Adapter } from '../adapter';
 
 export const dbOptions = {
   connectionString: process.env.DATABASE_URL,
@@ -64,7 +64,8 @@ export const Chat = db('chat', (t) => ({
 }));
 
 export const UniqueTable = db('uniqueTable', (t) => ({
-  one: t.text().unique(),
+  id: t.serial().primaryKey(),
+  one: t.text().unique().primaryKey(),
   two: t.integer().unique(),
   thirdColumn: t.text(),
   fourthColumn: t.integer(),

package/src/test-utils/user.csv

@@ -0,0 +1 @@
+1,name,password,,,,,,,,

package/src/utils.test.ts

@@ -1,4 +1,4 @@
-import { assertType } from './test-utils';
+import { assertType } from './test-utils/test-utils';
 import {
   makeRegexToFindInSql,
   MaybeArray,