enable using primary keys of BigInt

Author: andyli

src/tink/sql/Query.hx

@@ -12,7 +12,7 @@ enum Query<Db, Result> {
   // Multi(queries: Array<Query<Db, Any>>):Query<Db, Promise<Noise>>;
   Union<Row:{}>(union:UnionOperation<Db, Row>):Query<Db, RealStream<Row>>;
   Select<Row:{}>(select:SelectOperation<Db, Row>):Query<Db, RealStream<Row>>;
-  Insert<Row:{}>(insert:InsertOperation<Db, Row>):Query<Db, Promise<Id<Row>>>;
+  Insert<Row:{},IdType>(insert:InsertOperation<Db, Row>):Query<Db, Promise<IdType>>;
   Update<Row:{}>(update:UpdateOperation<Row>):Query<Db, Promise<{rowsAffected:Int}>>;
   Delete<Row:{}>(delete:DeleteOperation<Row>):Query<Db, Promise<{rowsAffected:Int}>>;
   CallProcedure<Row:{}>(call:CallOperation<Row>):Query<Db, RealStream<Row>>;

src/tink/sql/Table.hx

@@ -20,7 +20,7 @@ class Table<T> {
 }
 #end
 
-class TableSource<Fields, Filter:(Fields->Condition), Row:{}, Db> 
+class TableSource<Fields, Filter:(Fields->Condition), Row:{}, IdType, Db> 
     extends Selectable<Fields, Filter, Row, Db>
 {
 
@@ -78,17 +78,17 @@ class TableSource<Fields, Filter:(Fields->Condition), Row:{}, Db>
     );
   }
 
-  public function insertMany(rows:Array<Row>, ?options): Promise<Id<Row>>
+  public function insertMany(rows:Array<Row>, ?options): Promise<IdType>
     return if (rows.length == 0) cast Promise #if (tink_core >= "2") .NOISE #else .NULL #end
       else insert(Literal(rows), options);
 
-  public function insertOne(row:Row, ?options): Promise<Id<Row>>
+  public function insertOne(row:Row, ?options): Promise<IdType>
     return insert(Literal([row]), options);
 
-  public function insertSelect(selected:Selected<Dynamic, Dynamic, Row, Db>, ?options): Promise<Id<Row>>
+  public function insertSelect(selected:Selected<Dynamic, Dynamic, Row, Db>, ?options): Promise<IdType>
     return insert(Select(selected.toSelectOp()), options);
 
-  function insert(data, ?options:{?ignore:Bool, ?replace:Bool, ?update:Fields->Update<Row>}): Promise<Id<Row>> {
+  function insert(data, ?options:{?ignore:Bool, ?replace:Bool, ?update:Fields->Update<Row>}): Promise<IdType> {
     return cnx.execute(Insert({
       table: info, 
       data: data, 
@@ -122,12 +122,12 @@ class TableSource<Fields, Filter:(Fields->Condition), Row:{}, Db>
 
   macro public function as(e:Expr, alias:String) {
     return switch haxe.macro.Context.typeof(e) {
-      case TInst(_.get() => { pack: pack, name: name, superClass: _.params => [fields, _, row, _] }, _):
+      case TInst(_.get() => { pack: pack, name: name, superClass: _.params => [fields, _, row, idType, _] }, _):
         var fieldsType = fields.toComplex({direct: true});
         var filterType = (macro function ($alias:$fieldsType):tink.sql.Expr.Condition return tink.sql.Expr.ExprData.EValue(true, tink.sql.Expr.ExprType.VBool)).typeof().sure();
         var path: haxe.macro.TypePath = 
         'tink.sql.Table.TableSource'.asTypePath(
-          [fields, filterType, row].map(function (type)
+          [fields, filterType, row, idType].map(function (type)
             return TPType(type.toComplex({direct: true}))
           ).concat([TPType(e.pos.makeBlankType())])
         );

src/tink/sql/Types.hx

@@ -1,5 +1,6 @@
 package tink.sql;
 
+import haxe.*;
 import tink.sql.Expr;
 
 typedef Blob<@:const L> = haxe.io.Bytes;
@@ -63,10 +64,25 @@ abstract Id<T>(Int) to Int {
 
 }
 
+abstract Id64<T>(Int64) to Int64 {
 
+  public inline function new(v)
+    this = v;
 
+  @:from static inline function ofInt64<T>(i:Int64):Id64<T>
+    return new Id64(i);
 
+  @:to public inline function toString()
+    return Int64.toStr(this);
 
+  @:to public function toExpr():Expr<Id64<T>>
+    return tink.sql.Expr.ExprData.EValue(new Id64(this), cast VInt64);
 
+  @:op(A>B) static function gt<T>(a:Id64<T>, b:Id64<T>):Bool;
+  @:op(A<B) static function lt<T>(a:Id64<T>, b:Id64<T>):Bool;
+  @:op(A>=B) static function gte<T>(a:Id64<T>, b:Id64<T>):Bool;
+  @:op(A>=B) static function lte<T>(a:Id64<T>, b:Id64<T>):Bool;
+  @:op(A==B) static function eq<T>(a:Id64<T>, b:Id64<T>):Bool;
+  @:op(A!=B) static function neq<T>(a:Id64<T>, b:Id64<T>):Bool;
 
-
+}

src/tink/sql/format/CockroachDbFormatter.hx

@@ -103,6 +103,9 @@ class CockroachDbFormatter extends SqlFormatter<CockroachDbColumnInfo, Cockroach
       case DInt(Default, _, true, _):
         ident(column.name)
           .add(sql('SERIAL4'));
+      case DInt(Big, _, true, _):
+        ident(column.name)
+          .add(sql('SERIAL8'));
       case _:
         super.defineColumn(column);
     }

src/tink/sql/format/PostgreSqlFormatter.hx

@@ -92,6 +92,9 @@ class PostgreSqlFormatter extends SqlFormatter<PostgreSqlColumnInfo, PostgreSqlK
       case DInt(Default, _, true, _):
         ident(column.name)
           .add(sql('SERIAL'));
+      case DInt(Big, _, true, _):
+        ident(column.name)
+          .add(sql('BIGSERIAL'));
       case _:
         super.defineColumn(column);
     }

src/tink/sql/macros/TableBuilder.hx

@@ -7,6 +7,7 @@ import haxe.macro.Expr;
 import tink.sql.schema.KeyStore;
 
 using tink.MacroApi;
+using Lambda;
 
 class TableBuilder {
 
@@ -203,8 +204,16 @@ class TableBuilder {
             var fieldsAlias = define(fieldsType, 'FieldsOf_${readableName}');
             var rowAlias = define(rowType, 'ResultOf_${readableName}');
             var filterType = (macro function ($name:$fieldsAlias):tink.sql.Expr.Condition return tink.sql.Expr.ExprData.EValue(true, tink.sql.Expr.ExprType.VBool)).typeof().sure().toComplex({ direct: true });
-
-            macro class $cName<Db> extends tink.sql.Table.TableSource<$fieldsAlias, $filterType, $rowAlias, Db> {
+            var idType = switch (keys.get()[0]) {
+              case null:
+                macro:tink.sql.Types.Id<$rowAlias>;
+              case Primary([keyField]) if (fields.find(f -> f.name == keyField).meta.has(':autoIncrement')):
+                final keyFieldType = fields.find(f -> f.name == keyField).type.toComplex();
+                macro:$keyFieldType;
+              case _:
+                macro:tink.sql.Types.Id<$rowAlias>;
+            };
+            macro class $cName<Db> extends tink.sql.Table.TableSource<$fieldsAlias, $filterType, $rowAlias, $idType, Db> {
 
               public function new(cnx, tableName, ?alias) {
                 final name = new tink.sql.Table.TableName(tableName);

tests/BigIntTest.hx

@@ -32,7 +32,7 @@ class BigIntTest extends TestWithDb {
       intMin: int64Min,
       intMax: int64Max,
     })
-      .next(function(id:Int) return db.BigIntTypes.first())
+      .next(function(id:tink.sql.Types.BigInt) return db.BigIntTypes.where(r -> r.id == id).first())
       .next(function(row:BigIntTypes) {
         asserts.assert(row.int0 == 0);
         asserts.assert(row.intMin == int64Min);

tests/Db.hx

@@ -103,7 +103,7 @@ typedef Schema = {
 }
 
 typedef BigIntTypes = {
-  @:autoIncrement @:primary public var id(default, null):Id<User>;
+  @:autoIncrement @:primary public var id(default, null):BigInt;
   public var int0(default, null): BigInt;
   public var intMin(default, null): BigInt;
   public var intMax(default, null): BigInt;