@ultipa-graph/ultipa-driver
Version:
NodeJS SDK for ultipa-server 5.2
288 lines • 11.5 kB
JavaScript
;
Object.defineProperty(exports, "__esModule", { value: true });
exports.DESERIALIZE = void 0;
const ultipa_pb_1 = require("../../proto/ultipa_pb");
const ultipa_datetime_1 = require("../ultipa.datetime");
const commont_1 = require("./commont");
const null_1 = require("./null");
const types_1 = require("../../types/types");
const GlobalTextDecoder = new TextDecoder("utf-8");
var DESERIALIZE;
(function (DESERIALIZE) {
function deserialize(v, type, subTypes, timezone) {
// console.log(`type: ${PropertyUtils.propertyGet(<any>type)}:`, v)
const { STRING, FLOAT, DOUBLE, UINT32, INT64, UINT64, DATETIME, TIMESTAMP, TEXT, BLOB, POINT, DECIMAL, LIST, SET, MAP, } = types_1.UltipaPropertyType;
switch (type) {
case LIST:
if (commont_1.TypeSupport.list) {
return list(v, subTypes, timezone);
}
commont_1.TypeSupport.NotSupport(type);
return;
case MAP:
if (commont_1.TypeSupport.map) {
return map(v, subTypes, timezone);
}
commont_1.TypeSupport.NotSupport(type);
return;
case SET:
return set(v, subTypes, timezone);
}
return base(v, type, timezone);
}
DESERIALIZE.deserialize = deserialize;
;
function base(v, type, timezone) {
if (null_1.NullUtils.isNullValueByBytes(v, type)) {
return null;
}
const { INT32, BOOL, STRING, FLOAT, DOUBLE, UINT32, INT64, UINT64, DATETIME, TIMESTAMP, TEXT, BLOB, POINT, DECIMAL, LIST, SET, MAP, LOCAL_DATETIME, ZONED_DATETIME, YEAR_TO_MONTH, DAY_TO_SECOND, DATE, LOCAL_TIME, ZONED_TIME } = types_1.UltipaPropertyType;
let convertV;
switch (type) {
case INT32:
convertV = new DataView(v.buffer).getInt32(v.byteOffset);
break;
case BOOL:
let b = v.toString();
if (b == "48") {
convertV = false;
}
else {
convertV = true;
}
break;
case STRING:
case TEXT:
case DECIMAL:
convertV = GlobalTextDecoder.decode(v);
break;
case POINT:
if (16 != v.byteLength) {
convertV = GlobalTextDecoder.decode(v);
break;
}
let latitude_v = v.slice(0, 8);
let latitude = new DataView(latitude_v.buffer).getFloat64(latitude_v.byteOffset).toString();
let longitude_v = v.slice(8, 16);
let longitude = new DataView(longitude_v.buffer).getFloat64(longitude_v.byteOffset).toString();
convertV = `POINT(${latitude} ${longitude})`;
break;
case BLOB:
convertV = Buffer.from(v);
break;
case FLOAT:
convertV = Number(new DataView(v.buffer).getFloat32(v.byteOffset).toPrecision(7)).toString();
break;
case DOUBLE:
convertV = new DataView(v.buffer).getFloat64(v.byteOffset).toString();
break;
case TIMESTAMP:
convertV = new DataView(v.buffer).getUint32(v.byteOffset);
break;
case UINT32:
convertV = new DataView(v.buffer).getUint32(v.byteOffset);
break;
case INT64:
convertV = new DataView(v.buffer).getBigInt64(v.byteOffset).toString();
break;
case UINT64:
case DATETIME:
convertV = new DataView(v.buffer).getBigUint64(v.byteOffset).toString();
break;
case DATE:
case DAY_TO_SECOND:
case LOCAL_DATETIME:
case LOCAL_TIME:
case YEAR_TO_MONTH:
case ZONED_DATETIME:
case ZONED_TIME:
convertV = deserializeTimeField(v, type);
break;
}
if (type == TIMESTAMP && timezone.timestampToString) {
convertV = ultipa_datetime_1.UltipaDatetime.timestamp2Str(convertV, timezone);
}
if (type == DATETIME) {
convertV = ultipa_datetime_1.UltipaDatetime.datetimeInt2datetimeStr(convertV);
}
return convertV;
}
DESERIALIZE.base = base;
function list(v, types, timezone) {
try {
let data = ultipa_pb_1.ListData.deserializeBinary(v);
if (data.getIsNull()) {
return null;
}
let values = data.getValuesList_asU8();
let type = types[0];
let results = [];
values.forEach((v, i) => {
results.push(base(v, type, timezone));
});
return results;
}
catch (e) {
console.log("deserialize>list", v, e);
return [];
}
}
DESERIALIZE.list = list;
function map(v, types, timezone) {
try {
let data = ultipa_pb_1.MapData.deserializeBinary(v);
if (data.getIsNull()) {
return null;
}
let values = data.getValuesList();
let keyType = types[0];
let valueType = types[1];
let obj = {};
values.forEach((m) => {
let key = base(m.getKey_asU8(), keyType, timezone);
let value = base(m.getValue_asU8(), valueType, timezone);
obj[key] = value;
});
return obj;
}
catch (e) {
console.log("deserialize>list", v, e);
return [];
}
}
DESERIALIZE.map = map;
function set(v, types, timezone) {
try {
let data = ultipa_pb_1.SetData.deserializeBinary(v);
if (data.getIsNull()) {
return null;
}
let values = data.getValuesList_asU8();
let type = types[0];
let results = [];
values.forEach((v, i) => {
results.push(base(v, type, timezone));
});
return results;
}
catch (e) {
console.log("deserialize>set", v, e);
return [];
}
}
DESERIALIZE.set = set;
function deserializeTimeField(v, type) {
const { DATE, DAY_TO_SECOND, LOCAL_DATETIME, LOCAL_TIME, YEAR_TO_MONTH, ZONED_DATETIME, ZONED_TIME } = types_1.UltipaPropertyType;
if (!v || v.length === 0)
return null;
const dv = new DataView(v.buffer, v.byteOffset, v.byteLength);
switch (type) {
case DATE:
return decodeUtpDate(dv);
case LOCAL_TIME:
return decodeUtpTime(dv);
case ZONED_TIME:
return decodeUtpTime(dv, true);
case LOCAL_DATETIME:
return decodeUtpDatetime(dv);
case ZONED_DATETIME:
return decodeUtpDatetime(dv, true);
case YEAR_TO_MONTH:
return decodeUtpDurationYTM(dv);
case DAY_TO_SECOND:
return decodeUtpDurationDTS(dv);
default:
throw new Error(`Unsupported time field type: ${type}`);
}
function decodeUtpDate(dv, offset = 0) {
const value = dv.getUint32(offset);
const year = ((value >> 9) & 0x7FFF) - 16384;
const month = (value >> 5) & 0x0F;
const day = value & 0x1F;
return `${padYear(year)}-${pad(month)}-${pad(day)}`;
}
function decodeUtpTime(dv, withTz = false, offset = 0) {
const value = dv.getBigUint64(offset);
const hour = Number((value >> BigInt(59)) & BigInt(0x1F));
const minute = Number((value >> BigInt(53)) & BigInt(0x3F));
const second = Number((value >> BigInt(47)) & BigInt(0x3F));
const rawTZ = Number((value >> BigInt(40)) & BigInt(0x7F));
const tz = (rawTZ & 0x40) != 0 ? (rawTZ | 0xFFFFFF80) : rawTZ;
const nano = Number(value & BigInt(0x3FFFFFFF));
let result = `${pad(hour)}:${pad(minute)}:${pad(second)}`;
if (nano > 0) {
const nsStr = nano.toString().padStart(9, '0').replace(/0+$/, '');
result += `.${nsStr}`;
}
if (withTz) {
let totalMin = tz * 15;
let sign = totalMin >= 0 ? "+" : "-";
let absMin = Math.abs(totalMin);
result += `${sign}${pad(absMin / 60)}${pad(absMin % 60)}`;
}
return result;
}
function decodeUtpDatetime(dv, withTz = false) {
const dateStr = decodeUtpDate(dv, 0);
const timeStr = decodeUtpTime(dv, withTz, 4);
return `${dateStr} ${timeStr}`;
}
function decodeUtpDurationYTM(dv) {
const total = dv.getInt32(0);
const isNeg = total < 0;
const months = Math.abs(total);
const y = Math.floor(months / 12);
const m = months % 12;
let str = (isNeg ? "-" : "") + "P";
if (y > 0)
str += `${y}Y`;
if (m > 0)
str += `${m}M`;
if (y === 0 && m === 0)
str += "0M";
return str;
}
function decodeUtpDurationDTS(dv) {
const totalNs = dv.getBigInt64(0);
const isNeg = totalNs < 0n;
let ns = isNeg ? -totalNs : totalNs;
const oneSec = 1000000000n;
const oneMin = 60n * oneSec;
const oneHour = 60n * oneMin;
const oneDay = 24n * oneHour;
const days = ns / oneDay;
ns %= oneDay;
const hours = ns / oneHour;
ns %= oneHour;
const minutes = ns / oneMin;
ns %= oneMin;
const seconds = ns / oneSec;
const nanos = ns % oneSec;
let result = (isNeg ? "-" : "") + "P";
result += `${days}D`;
if (hours || minutes || seconds || nanos)
result += "T";
if (hours)
result += `${hours}H`;
if (minutes)
result += `${minutes}M`;
if (seconds || nanos) {
result += `${seconds}`;
if (nanos > 0n) {
const nanoStr = nanos.toString().padStart(9, '0').replace(/0+$/, '');
result += `.${nanoStr}`;
}
result += "S";
}
return result;
}
function pad(num) {
return num < 10 ? `0${Math.floor(num)}` : `${Math.floor(num)}`;
}
function padYear(year) {
return year.toString().padStart(4, '0');
}
}
DESERIALIZE.deserializeTimeField = deserializeTimeField;
})(DESERIALIZE = exports.DESERIALIZE || (exports.DESERIALIZE = {}));
//# sourceMappingURL=deserialize.js.map