2.00.13

In this release, rollbacks to previous versions are impossible after the following actions:

• Using SQL DELETE or INSERT INTO statements in scripts involving function persistence (e.g., function views, scheduled jobs). This is due to changes in the persistence protocol for the two statements.

• Adding a scheduled job, or triggering a checkpoint (which generates a jobCheckPoint.meta file in the sysmgmt directory) by adding/deleteing scheduled jobs.

• Modified the data types of columns “*_allowed“ and “*_denied“ returned by getUserAccess and getGroupAccess from STRING to BLOB. (2.00.13.3)

• Modified the behavior of flatten. The following operations are allowed since this release (2.00.13.3).

  • Flattening a tuple containing NULL values.

    flatten((3, NULL, 5)) 
    // Error (previous releases): Couldn't flatten the vector because some elements of the vector have inconsistent types.'
    // Output (current release): [3,,5]

  • Flattening a tuple containing tuples and other data forms.

    flatten([(1, "aa"), 2.5, 3])
    // Error (previous releases): Couldn't flatten the vector because some elements of the vector have inconsistent types.'
    // Output (current release): [1,aa,2.5,3]

• Modified the default value of snapshot parameter for the restore function from true to false. This change prevents potential deletion of non-backed up data during subsequent restores, enhancing data safety.

• Behavior change for type conversion of subarrays. Converting a subarray of the big array now returns HUGE <DATATYPE> VECTOR instead of the previously returned FAST <DATATYPE> VECTOR.

  x=bigarray(INT,10,10000000,1)
  subx=subarray(x, 0:5000)
  // convert the data type of subx and check its type
  typestr(char(subx))
  // Output(previous releases): FAST CHAR VECTOR
  // Output(since this release): HUGE CHAR VECTOR

• Adjusted the result precision for functions std, stdp, var, varp, skew, kurtosis and their related m- and tm-functions to match Python standards when the calculation involves extreme values.
• Modified the behavior of flatten when handling a tuple of tuples:

  • In previous releases, the tuple was flattened to a 1d vector.

  • Since this release, each tuple element is converted to a 1d vector and a tuple is returned.

    list2 = (("aa", "bb", "cc"), ("dd", "ee", "ff"))
    flatten(list2)
    // Output (previous releases): STRING VECTOR:[`aa,`bb,`cc,`dd,`ee,`ff]
    // Output (current release): ANY VECTOR (["aa", "bb", "cc"], ["dd", "ee", "ff"])

• In previous releases, a user-defined JIT function returning multiple scalars in definition would return a vector. Since this release, a tuple is returned.

  @jit
  def f(a, b, c){
      return a, b, c
  }
  ​
  a = 1
  b = -1
  c = int(NULL)
  ​
  typestr(f(a, b, c))
  // Output (previous releases): FAST INT VECTOR
  // Output (current release): ANY VECTOR