gremlin 3.7.5 → 3.8.0

package/lib/process/graph-traversal.js

@@ -24,7 +24,6 @@
 
 const { Traversal, cardinality } = require('./traversal');
 const { Transaction } = require('./transaction');
-const remote = require('../driver/remote-connection');
 const Bytecode = require('./bytecode');
 const { TraversalStrategies, VertexProgramStrategy, OptionsStrategy } = require('./traversal-strategy');
 
@@ -46,30 +45,10 @@ class GraphTraversalSource {
     this.bytecode = bytecode || new Bytecode();
     this.graphTraversalSourceClass = graphTraversalSourceClass || GraphTraversalSource;
     this.graphTraversalClass = graphTraversalClass || GraphTraversal;
-
-    // in order to keep the constructor unchanged within 3.5.x we can try to pop the RemoteConnection out of the
-    // TraversalStrategies. keeping this unchanged will allow user DSLs to not take a break.
-    // TODO: refactor this to be nicer in 3.6.0 when we can take a breaking change
     const strat = traversalStrategies.strategies.find((ts) => ts.fqcn === 'js:RemoteStrategy');
     this.remoteConnection = strat !== undefined ? strat.connection : undefined;
   }
 
-  /**
-   * @param {RemoteConnection} remoteConnection
-   * @returns {GraphTraversalSource}
-   */
-  withRemote(remoteConnection) {
-    const traversalStrategy = new TraversalStrategies(this.traversalStrategies);
-    traversalStrategy.addStrategy(new remote.RemoteStrategy(remoteConnection));
-    return new this.graphTraversalSourceClass(
-      this.graph,
-      traversalStrategy,
-      new Bytecode(this.bytecode),
-      this.graphTraversalSourceClass,
-      this.graphTraversalClass,
-    );
-  }
-
   /**
    * Spawn a new <code>Transaction</code> object that can then start and stop a transaction.
    * @returns {Transaction}
@@ -454,6 +433,16 @@ class GraphTraversal extends Traversal {
     return this;
   }
 
+  /**
+   * Graph traversal asBool method.
+   * @param {...Object} args
+   * @returns {GraphTraversal}
+   */
+  asBool(...args) {
+    this.bytecode.addStep('asBool', args);
+    return this;
+  }
+
   /**
    * Graph traversal asDate method.
    * @param {...Object} args
@@ -464,6 +453,16 @@ class GraphTraversal extends Traversal {
     return this;
   }
 
+  /**
+   * Graph traversal asNumber method.
+   * @param {...Object} args
+   * @returns {GraphTraversal}
+   */
+  asNumber(...args) {
+    this.bytecode.addStep('asNumber', args);
+    return this;
+  }
+
   /**
    * Graph traversal asString method.
    * @param {...Object} args
@@ -693,6 +692,16 @@ class GraphTraversal extends Traversal {
     return this;
   }
 
+  /**
+   * Graph traversal discard method.
+   * @param {...Object} args
+   * @returns {GraphTraversal}
+   */
+  discard(...args) {
+    this.bytecode.addStep('discard', args);
+    return this;
+  }
+
   /**
    * Graph traversal disjunct method.
    * @param {...Object} args
@@ -1472,16 +1481,6 @@ class GraphTraversal extends Traversal {
     return this;
   }
 
-  /**
-   * Graph traversal store method.
-   * @param {...Object} args
-   * @returns {GraphTraversal}
-   */
-  store(...args) {
-    this.bytecode.addStep('store', args);
-    return this;
-  }
-
   /**
    * Graph traversal subgraph method.
    * @param {...Object} args
@@ -1761,7 +1760,9 @@ const statics = {
   and: (...args) => callOnEmptyTraversal('and', args),
   any: (...args) => callOnEmptyTraversal('any', args),
   as: (...args) => callOnEmptyTraversal('as', args),
+  asBool: (...args) => callOnEmptyTraversal('asBool', args),
   asDate: (...args) => callOnEmptyTraversal('asDate', args),
+  asNumber: (...args) => callOnEmptyTraversal('asNumber', args),
   asString: (...args) => callOnEmptyTraversal('asString', args),
   barrier: (...args) => callOnEmptyTraversal('barrier', args),
   both: (...args) => callOnEmptyTraversal('both', args),
@@ -1783,6 +1784,7 @@ const statics = {
   dateDiff: (...args) => callOnEmptyTraversal('dateDiff', args),
   dedup: (...args) => callOnEmptyTraversal('dedup', args),
   difference: (...args) => callOnEmptyTraversal('difference', args),
+  discard: (...args) => callOnEmptyTraversal('discard', args),
   disjunct: (...args) => callOnEmptyTraversal('disjunct', args),
   drop: (...args) => callOnEmptyTraversal('drop', args),
   element: (...args) => callOnEmptyTraversal('element', args),
@@ -1853,7 +1855,6 @@ const statics = {
   simplePath: (...args) => callOnEmptyTraversal('simplePath', args),
   skip: (...args) => callOnEmptyTraversal('skip', args),
   split: (...args) => callOnEmptyTraversal('split', args),
-  store: (...args) => callOnEmptyTraversal('store', args),
   subgraph: (...args) => callOnEmptyTraversal('subgraph', args),
   substring: (...args) => callOnEmptyTraversal('substring', args),
   sum: (...args) => callOnEmptyTraversal('sum', args),

package/lib/process/traversal-strategy.js

@@ -102,7 +102,7 @@ class HaltedTraverserStrategy extends TraversalStrategy {
   /**
    * @param {String} haltedTraverserFactory full qualified class name in Java of a {@code HaltedTraverserFactory} implementation
    */
-  constructor(haltedTraverserFactory) {
+  constructor({ haltedTraverserFactory } = {}) {
     super('org.apache.tinkerpop.gremlin.process.traversal.strategy.decoration.HaltedTraverserStrategy');
     if (haltedTraverserFactory !== undefined) {
       this.configuration['haltedTraverserFactory'] = haltedTraverserFactory;
@@ -110,9 +110,20 @@ class HaltedTraverserStrategy extends TraversalStrategy {
   }
 }
 
+class MessagePassingReductionStrategy extends TraversalStrategy {
+  constructor() {
+    super(
+      'org.apache.tinkerpop.gremlin.process.computer.traversal.strategy.optimization.MessagePassingReductionStrategy',
+    );
+  }
+}
+
 class OptionsStrategy extends TraversalStrategy {
   constructor(options) {
-    super('org.apache.tinkerpop.gremlin.process.traversal.strategy.decoration.OptionsStrategy', options);
+    super('org.apache.tinkerpop.gremlin.process.traversal.strategy.decoration.OptionsStrategy');
+    if (options !== undefined) {
+      this.configuration = options;
+    }
   }
 }
 
@@ -129,6 +140,24 @@ class PartitionStrategy extends TraversalStrategy {
   }
 }
 
+class ProfileStrategy extends TraversalStrategy {
+  constructor() {
+    super('org.apache.tinkerpop.gremlin.process.traversal.strategy.finalization.ProfileStrategy');
+  }
+}
+
+class SeedStrategy extends TraversalStrategy {
+  /**
+   * @param {Object} [options]
+   * @param {number} [options.seed] the seed to provide to the random number generator for the traversal
+   */
+  constructor(options) {
+    super('org.apache.tinkerpop.gremlin.process.traversal.strategy.decoration.SeedStrategy', {
+      seed: options?.seed,
+    });
+  }
+}
+
 class SubgraphStrategy extends TraversalStrategy {
   /**
    * @param {Object} [options]
@@ -151,13 +180,9 @@ class SubgraphStrategy extends TraversalStrategy {
   }
 }
 
-class ProductiveByStrategy extends TraversalStrategy {
-  /**
-   * @param {Object} [options]
-   * @param {Array<String>} [options.productiveKeys] set of keys that will always be productive
-   */
-  constructor(options) {
-    super('org.apache.tinkerpop.gremlin.process.traversal.strategy.optimization.ProductiveByStrategy', options);
+class ReferenceElementStrategy extends TraversalStrategy {
+  constructor() {
+    super('org.apache.tinkerpop.gremlin.process.traversal.strategy.finalization.ReferenceElementStrategy');
   }
 }
 
@@ -171,7 +196,7 @@ class MatchAlgorithmStrategy extends TraversalStrategy {
   /**
    * @param matchAlgorithm
    */
-  constructor(matchAlgorithm) {
+  constructor({ matchAlgorithm } = {}) {
     super('org.apache.tinkerpop.gremlin.process.traversal.strategy.finalization.MatchAlgorithmStrategy');
     if (matchAlgorithm !== undefined) {
       this.configuration['matchAlgorithm'] = matchAlgorithm;
@@ -179,12 +204,24 @@ class MatchAlgorithmStrategy extends TraversalStrategy {
   }
 }
 
+class ComputerFinalizationStrategy extends TraversalStrategy {
+  constructor() {
+    super('org.apache.tinkerpop.gremlin.process.computer.traversal.strategy.finalization.ComputerFinalizationStrategy');
+  }
+}
+
 class AdjacentToIncidentStrategy extends TraversalStrategy {
   constructor() {
     super('org.apache.tinkerpop.gremlin.process.traversal.strategy.optimization.AdjacentToIncidentStrategy');
   }
 }
 
+class ByModulatorOptimizationStrategy extends TraversalStrategy {
+  constructor() {
+    super('org.apache.tinkerpop.gremlin.process.traversal.strategy.optimization.ByModulatorOptimizationStrategy');
+  }
+}
+
 class FilterRankingStrategy extends TraversalStrategy {
   constructor() {
     super('org.apache.tinkerpop.gremlin.process.traversal.strategy.optimization.FilterRankingStrategy');
@@ -239,6 +276,17 @@ class PathRetractionStrategy extends TraversalStrategy {
   }
 }
 
+class ProductiveByStrategy extends TraversalStrategy {
+  /**
+   * @param {Object} [options]
+   * @param {Array<String>} productiveKeys set of keys that will always be productive
+   */
+  constructor({ productiveKeys = [] } = {}) {
+    super('org.apache.tinkerpop.gremlin.process.traversal.strategy.optimization.ProductiveByStrategy');
+    this.configuration['productiveKeys'] = productiveKeys;
+  }
+}
+
 class CountStrategy extends TraversalStrategy {
   constructor() {
     super('org.apache.tinkerpop.gremlin.process.traversal.strategy.optimization.CountStrategy');
@@ -253,7 +301,7 @@ class RepeatUnrollStrategy extends TraversalStrategy {
 
 class GraphFilterStrategy extends TraversalStrategy {
   constructor() {
-    super('org.apache.tinkerpop.gremlin.process.traversal.strategy.optimization.GraphFilterStrategy');
+    super('org.apache.tinkerpop.gremlin.process.computer.traversal.strategy.optimization.GraphFilterStrategy');
   }
 }
 
@@ -263,6 +311,12 @@ class EarlyLimitStrategy extends TraversalStrategy {
   }
 }
 
+class ComputerVerificationStrategy extends TraversalStrategy {
+  constructor() {
+    super('org.apache.tinkerpop.gremlin.process.traversal.strategy.verification.ComputerVerificationStrategy');
+  }
+}
+
 class LambdaRestrictionStrategy extends TraversalStrategy {
   constructor() {
     super('org.apache.tinkerpop.gremlin.process.traversal.strategy.verification.LambdaRestrictionStrategy');
@@ -280,11 +334,10 @@ class EdgeLabelVerificationStrategy extends TraversalStrategy {
    * @param {boolean} logWarnings determines if warnings should be written to the logger when verification fails
    * @param {boolean} throwException determines if exceptions should be thrown when verifications fails
    */
-  constructor(logWarnings = false, throwException = false) {
-    super('org.apache.tinkerpop.gremlin.process.traversal.strategy.verification.EdgeLabelVerificationStrategy', {
-      logWarnings: logWarnings,
-      throwException: throwException,
-    });
+  constructor({ logWarnings = false, throwException = false } = {}) {
+    super('org.apache.tinkerpop.gremlin.process.traversal.strategy.verification.EdgeLabelVerificationStrategy');
+    this.configuration['logWarnings'] = logWarnings;
+    this.configuration['throwException'] = throwException;
   }
 }
 
@@ -294,24 +347,25 @@ class ReservedKeysVerificationStrategy extends TraversalStrategy {
    * @param {boolean} throwException determines if exceptions should be thrown when verifications fails
    * @param {Array<String>} keys the list of reserved keys to verify
    */
-  constructor(logWarnings = false, throwException = false, keys = ['id', 'label']) {
-    super('org.apache.tinkerpop.gremlin.process.traversal.strategy.verification.ReservedKeysVerificationStrategy', {
-      logWarnings: logWarnings,
-      throwException: throwException,
-      keys: keys,
-    });
+  constructor({ logWarnings = false, throwException = false, keys = ['id', 'label'] } = {}) {
+    super('org.apache.tinkerpop.gremlin.process.traversal.strategy.verification.ReservedKeysVerificationStrategy');
+    this.configuration['logWarnings'] = logWarnings;
+    this.configuration['throwException'] = throwException;
+    this.configuration['keys'] = keys;
   }
 }
 
-class SeedStrategy extends TraversalStrategy {
-  /**
-   * @param {Object} [options]
-   * @param {number} [options.seed] the seed to provide to the random number generator for the traversal
-   */
-  constructor(options) {
-    super('org.apache.tinkerpop.gremlin.process.traversal.strategy.decoration.SeedStrategy', {
-      seed: options.seed,
-    });
+class VertexProgramRestrictionStrategy extends TraversalStrategy {
+  constructor() {
+    super(
+      'org.apache.tinkerpop.gremlin.process.computer.traversal.strategy.verification.VertexProgramRestrictionStrategy',
+    );
+  }
+}
+
+class StandardVerificationStrategy extends TraversalStrategy {
+  constructor() {
+    super('org.apache.tinkerpop.gremlin.process.traversal.strategy.verification.StandardVerificationStrategy');
   }
 }
 
@@ -319,11 +373,15 @@ module.exports = {
   TraversalStrategies: TraversalStrategies,
   TraversalStrategy: TraversalStrategy,
   // decoration
+  ComputerFinalizationStrategy: ComputerFinalizationStrategy,
   ConnectiveStrategy: ConnectiveStrategy,
   ElementIdStrategy: ElementIdStrategy,
   HaltedTraverserStrategy: HaltedTraverserStrategy,
+  MessagePassingReductionStrategy: MessagePassingReductionStrategy,
   OptionsStrategy: OptionsStrategy,
   PartitionStrategy: PartitionStrategy,
+  ProfileStrategy: ProfileStrategy,
+  ReferenceElementStrategy: ReferenceElementStrategy,
   SeedStrategy: SeedStrategy,
   SubgraphStrategy: SubgraphStrategy,
   VertexProgramStrategy: VertexProgramStrategy,
@@ -331,6 +389,7 @@ module.exports = {
   MatchAlgorithmStrategy: MatchAlgorithmStrategy,
   // optimization
   AdjacentToIncidentStrategy: AdjacentToIncidentStrategy,
+  ByModulatorOptimizationStrategy: ByModulatorOptimizationStrategy,
   FilterRankingStrategy: FilterRankingStrategy,
   IdentityRemovalStrategy: IdentityRemovalStrategy,
   IncidentToAdjacentStrategy: IncidentToAdjacentStrategy,
@@ -346,8 +405,11 @@ module.exports = {
   GraphFilterStrategy: GraphFilterStrategy,
   EarlyLimitStrategy: EarlyLimitStrategy,
   // verification
+  ComputerVerificationStrategy: ComputerVerificationStrategy,
   EdgeLabelVerificationStrategy: EdgeLabelVerificationStrategy,
   LambdaRestrictionStrategy: LambdaRestrictionStrategy,
   ReadOnlyStrategy: ReadOnlyStrategy,
   ReservedKeysVerificationStrategy: ReservedKeysVerificationStrategy,
+  StandardVerificationStrategy: StandardVerificationStrategy,
+  VertexProgramRestrictionStrategy: VertexProgramRestrictionStrategy,
 };

package/lib/process/traversal.js

@@ -84,7 +84,7 @@ class Traversal {
    * @returns {Promise}
    */
   iterate() {
-    this.bytecode.addStep('none');
+    this.bytecode.addStep('discard');
     return this._applyStrategies().then(() => {
       let it;
       while ((it = this._getNext()) && !it.done) {
@@ -345,6 +345,11 @@ class P {
     return createP('outside', args);
   }
 
+  /** @param {...Object} args */
+  static typeOf(...args) {
+    return createP('typeOf', args);
+  }
+
   /** @param {...Object} args */
   static test(...args) {
     return createP('test', args);
@@ -487,6 +492,14 @@ function toDirectionEnum(typeName, keys) {
   return result;
 }
 
+function toGTypeEnum(typeName, keys) {
+  const result = {};
+  keys.split(' ').forEach((k) => {
+    result[k] = new EnumValue(typeName, k.toUpperCase());
+  });
+  return result;
+}
+
 class EnumValue {
   constructor(typeName, elementName) {
     this.typeName = typeName;
@@ -512,12 +525,16 @@ module.exports = {
   column: toEnum('Column', 'keys values'),
   direction: toDirectionEnum('Direction', 'BOTH IN OUT from_ to'),
   dt: toEnum('DT', 'second minute hour day'),
+  gType: toGTypeEnum(
+    'GType',
+    'bigDecimal bigInt binary boolean byte char datetime double duration edge float graph int list long map null number path property set short string tree uuid vertex vproperty',
+  ),
   graphSONVersion: toEnum('GraphSONVersion', 'V1_0 V2_0 V3_0'),
   gryoVersion: toEnum('GryoVersion', 'V1_0 V3_0'),
   merge: toEnum('Merge', 'onCreate onMatch outV inV'),
   operator: toEnum('Operator', 'addAll and assign div max min minus mult or sum sumLong'),
   order: toEnum('Order', 'asc desc shuffle'),
-  pick: toEnum('Pick', 'any none'),
+  pick: toEnum('Pick', 'any none unproductive'),
   pop: toEnum('Pop', 'all first last mixed'),
   scope: toEnum('Scope', 'global local'),
   t: toEnum('T', 'id key label value'),

package/lib/structure/graph.js

@@ -46,9 +46,11 @@ class Graph {
 }
 
 class Element {
-  constructor(id, label) {
+  // properties are stored as list of property objects
+  constructor(id, label, properties = []) {
     this.id = id;
     this.label = label;
+    this.properties = properties != null ? properties : [];
   }
 
   /**
@@ -62,9 +64,8 @@ class Element {
 }
 
 class Vertex extends Element {
-  constructor(id, label, properties) {
-    super(id, label);
-    this.properties = properties;
+  constructor(id, label, properties = []) {
+    super(id, label, properties);
   }
 
   toString() {
@@ -73,20 +74,10 @@ class Vertex extends Element {
 }
 
 class Edge extends Element {
-  constructor(id, outV, label, inV, properties) {
-    super(id, label);
+  constructor(id, outV, label, inV, properties = []) {
+    super(id, label, properties);
     this.outV = outV;
     this.inV = inV;
-    this.properties = {};
-    if (properties) {
-      if (Array.isArray(properties)) {
-        // Handle array of Property objects
-        properties.forEach((prop) => (this.properties[prop.key] = prop.value));
-      } else {
-        // Handle object format as before
-        Object.keys(properties).forEach((k) => (this.properties[k] = properties[k].value));
-      }
-    }
   }
 
   toString() {
@@ -98,11 +89,10 @@ class Edge extends Element {
 }
 
 class VertexProperty extends Element {
-  constructor(id, label, value, properties) {
-    super(id, label);
+  constructor(id, label, value, properties = []) {
+    super(id, label, properties);
     this.value = value;
     this.key = this.label;
-    this.properties = properties;
   }
 
   toString() {

package/lib/structure/io/binary/GraphBinary.js

@@ -71,14 +71,15 @@ ioc.intSerializer               = new (require('./internals/IntSerializer'))(ioc
 ioc.longSerializer              = new (require('./internals/LongSerializer'))(ioc);
 ioc.longSerializerNg            = new (require('./internals/LongSerializerNg'))(ioc);
 ioc.stringSerializer            = new (require('./internals/StringSerializer'))(ioc, ioc.DataType.STRING);
+ioc.offsetDateTimeSerializer    = new (require('./internals/OffsetDateTimeSerializer'))(ioc, ioc.DataType.OFFSETDATETIME);
 ioc.dateSerializer              = new (require('./internals/DateSerializer'))(ioc, ioc.DataType.DATE);
 ioc.timestampSerializer         = new (require('./internals/DateSerializer'))(ioc, ioc.DataType.TIMESTAMP);
-ioc.classSerializer             = new (require('./internals/StringSerializer'))(ioc, ioc.DataType.CLASS);
+ioc.classSerializer             = new (require('./internals/ClassSerializer'))(ioc);
 ioc.doubleSerializer            = new (require('./internals/DoubleSerializer'))(ioc);
 ioc.floatSerializer             = new (require('./internals/FloatSerializer'))(ioc);
 ioc.listSerializer              = new (require('./internals/ArraySerializer'))(ioc, ioc.DataType.LIST);
 ioc.mapSerializer               = new (require('./internals/MapSerializer'))(ioc);
-ioc.setSerializer               = new (require('./internals/ArraySerializer'))(ioc, ioc.DataType.SET);
+ioc.setSerializer               = new (require('./internals/SetSerializer'))(ioc, ioc.DataType.SET);
 ioc.uuidSerializer              = new (require('./internals/UuidSerializer'))(ioc);
 ioc.edgeSerializer              = new (require('./internals/EdgeSerializer'))(ioc);
 ioc.pathSerializer              = new (require('./internals/PathSerializer'))(ioc);

package/lib/structure/io/binary/internals/AnySerializer.js

@@ -35,11 +35,13 @@ module.exports = class AnySerializer {
       ioc.numberSerializationStrategy,
 
       ioc.booleanSerializer,
+      ioc.offsetDateTimeSerializer,
       ioc.dateSerializer,
       ioc.bytecodeSerializer,
       ioc.pSerializer,
       ioc.traverserSerializer,
       ioc.enumSerializer,
+      ioc.setSerializer,
       ioc.listSerializer,
       ioc.uuidSerializer,
       ioc.edgeSerializer,
@@ -47,6 +49,7 @@ module.exports = class AnySerializer {
       ioc.propertySerializer,
       ioc.vertexSerializer,
       ioc.vertexPropertySerializer,
+      ioc.classSerializer,
       ioc.stringSerializer,
       ioc.textPSerializer,
       ioc.traversalStrategySerializer,

package/lib/structure/io/binary/internals/ClassSerializer.js

@@ -0,0 +1,60 @@
+/*
+ *  Licensed to the Apache Software Foundation (ASF) under one
+ *  or more contributor license agreements.  See the NOTICE file
+ *  distributed with this work for additional information
+ *  regarding copyright ownership.  The ASF licenses this file
+ *  to you under the Apache License, Version 2.0 (the
+ *  "License"); you may not use this file except in compliance
+ *  with the License.  You may obtain a copy of the License at
+ *
+ *  http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing,
+ *  software distributed under the License is distributed on an
+ *  "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ *  KIND, either express or implied.  See the License for the
+ *  specific language governing permissions and limitations
+ *  under the License.
+ */
+
+'use strict';
+
+const { TraversalStrategy } = require('../../../../process/traversal-strategy');
+const { Buffer } = require('buffer');
+
+module.exports = class ClassSerializer {
+  constructor(ioc) {
+    this.ioc = ioc;
+    this.ioc.serializers[ioc.DataType.CLASS] = this;
+  }
+
+  canBeUsedFor(value) {
+    return (
+      typeof value === 'function' &&
+      !!value.prototype &&
+      !!value.prototype.constructor.name &&
+      new value() instanceof TraversalStrategy
+    );
+  }
+
+  serialize(item, fullyQualifiedFormat = true) {
+    if (item === undefined || item === null) {
+      if (fullyQualifiedFormat) {
+        return Buffer.from([this.ioc.DataType.CLASS, 0x01]);
+      }
+      return this.ioc.intSerializer.serialize(0, false);
+    }
+
+    const bufs = [];
+    if (fullyQualifiedFormat) {
+      bufs.push(Buffer.from([this.ioc.DataType.CLASS, 0x00]));
+    }
+
+    const fqcn = new item().fqcn;
+    const v = Buffer.from(fqcn, 'utf8');
+    bufs.push(this.ioc.intSerializer.serialize(fqcn.length, false));
+    bufs.push(v);
+
+    return Buffer.concat(bufs);
+  }
+};

package/lib/structure/io/binary/internals/DataType.js

@@ -75,6 +75,7 @@ const DataType = {
   TRAVERSALMETRICS: 0x2d,
   MERGE: 0x2e,
   DT: 0x2f,
+  GTYPE: 0x30,
 
   CHAR: 0x80,
   DURATION: 0x81,

package/lib/structure/io/binary/internals/EnumSerializer.js

@@ -43,6 +43,7 @@ module.exports = class EnumSerializer {
       { name: 'Column', code: DT.COLUMN, enum: to_orig_enum(t.column) },
       { name: 'Direction', code: DT.DIRECTION, enum: to_orig_enum(t.direction) },
       { name: 'DT', code: DT.DT, enum: to_orig_enum(t.dt) },
+      { name: 'GType', code: DT.GTYPE, enum: to_orig_enum(t.gType) },
       { name: 'Merge', code: DT.MERGE, enum: to_orig_enum(t.merge) },
       { name: 'Operator', code: DT.OPERATOR, enum: to_orig_enum(t.operator) },
       { name: 'Order', code: DT.ORDER, enum: to_orig_enum(t.order) },

package/lib/structure/io/binary/internals/NumberSerializationStrategy.js

@@ -58,7 +58,12 @@ module.exports = class NumberSerializationStrategy {
         // INT32_MIN/MAX
         return this.ioc.intSerializer.serialize(item, fullyQualifiedFormat);
       }
-      return this.ioc.longSerializer.serialize(item, fullyQualifiedFormat);
+      // eslint-disable-next-line no-loss-of-precision
+      if (item >= -9223372036854775808 && item < 9223372036854775807) {
+        // INT64_MIN/MAX
+        return this.ioc.longSerializer.serialize(item, fullyQualifiedFormat);
+      }
+      return this.ioc.doubleSerializer.serialize(item, fullyQualifiedFormat);
     }
 
     if (typeof item === 'bigint') {