@malloydata/malloy-tests 0.0.433 → 0.0.435

package/src/databases/all/nomodel.spec.ts

@@ -652,26 +652,6 @@ runtimes.runtimeMap.forEach((runtime, databaseName) => {
     });
   });
 
-  test.when(runtime.supportsNesting)(
-    `number as null 2 - ${databaseName}`,
-    async () => {
-      // a cross join produces a Many to Many result.
-      // symmetric aggregate are needed on both sides of the join
-      // Check the row count and that sums on each side work properly.
-      const testModel = wrapTestModel(runtime, '');
-      await expect(`
-        # test.verbose
-        run: ${databaseName}.table('malloytest.state_facts') -> {
-          group_by: state
-          nest: ugly is {
-            group_by: popular_name
-            aggregate: foo is NULLIF(sum(airport_count)*0,0)+1
-          }
-        }
-      `).toMatchPaths(testModel, {'ugly.foo': null});
-    }
-  );
-
   it(`sql block- ${databaseName}`, async () => {
     const testModel = wrapTestModel(runtime, '');
     await expect(`
@@ -1279,39 +1259,6 @@ SELECT row_to_json(finalStage) as row FROM __stage0 AS finalStage`);
       `).toMatchResult(testModel, {p: 23001594});
   });
 
-  test.when(runtime.supportsNesting)(
-    `nest null - ${databaseName}`,
-    async () => {
-      const result = await runtime
-        .loadQuery(
-          `
-        run: ${databaseName}.table('malloytest.airports') -> {
-          where: faa_region is null
-          group_by: faa_region
-          aggregate: airport_count is count()
-          nest: by_state is {
-            where: state is not null
-            group_by: state
-            aggregate: airport_count is count()
-          }
-          nest: by_state1 is {
-            where: state is not null
-            group_by: state
-            aggregate: airport_count is count()
-            limit: 1
-          }
-        }
-      `
-        )
-        .run();
-
-      // eslint-disable-next-line @typescript-eslint/no-explicit-any
-      const d: any = result.data.toObject();
-      expect(d[0]['by_state']).not.toBe(null);
-      expect(d[0]['by_state1']).not.toBe(null);
-    }
-  );
-
   test.when(
     runtime.supportsNesting && runtime.dialect.supportsPipelinesInViews
   )(`Nested pipelines sort properly - ${databaseName}`, async () => {
@@ -1391,28 +1338,6 @@ SELECT row_to_json(finalStage) as row FROM __stage0 AS finalStage`);
     }
   });
 
-  test.when(runtime.supportsNesting)(
-    `number as null- ${databaseName}`,
-    async () => {
-      const result = await runtime
-        .loadQuery(
-          `
-        source: s is ${databaseName}.table('malloytest.state_facts') extend {
-        }
-        run: s-> {
-          group_by: state
-          nest: ugly is {
-            group_by: popular_name
-            aggregate: foo is NULLIF(sum(airport_count)*0,0)+1
-          }
-        }
-      `
-        )
-        .run();
-      expect(result.data.path(0, 'ugly', 0, 'foo').value).toBe(null);
-    }
-  );
-
   it(`removes surpuflous order_by - solo aggregates - ${databaseName}`, async () => {
     const result = await runtime
       .loadQuery(

package/src/databases/all/problems.spec.ts

@@ -36,11 +36,43 @@ runtimes.runtimeMap.forEach((runtime, databaseName) => {
             aggregate: \`#\` is count(one)
           }
         }
+        // A nest of nothing but aggregates is a single record rather than a
+        // list, and is built by a different dialect method.
+        nest: measures_only is {
+          aggregate: \`#\` is count(one)
+          aggregate: \`order\` is one.sum()
+        }
       }`).toMatchResult(testModel, {
       foo: [{'one': 1, '#': 1, 'deepfoo': [{'one': 1, '#': 1}]}],
+      measures_only: {'#': 1, 'order': 1},
     });
   });
 
+  // A nest's output field names are the user's, so every place a stage
+  // declares or reads them has to quote them -- including the row type a
+  // multi-stage nest builds to carry its first stage into its second.
+  test.when(
+    runtime.supportsNesting && runtime.dialect.supportsPipelinesInViews
+  )(
+    `properly quotes nested field names through a second stage in ${databaseName}`,
+    async () => {
+      await expect(`
+      run: ${databaseName}.table('malloytest.state_facts') -> {
+        where: state = 'CA'
+        group_by: popular_name
+        nest: counted is {
+          group_by: \`order\` is state
+          aggregate: n is count()
+        } -> {
+          group_by: \`order\`
+          aggregate: t is n.sum()
+        }
+      }`).toMatchResult(testModel, {
+        counted: [{'order': 'CA', 't': 1}],
+      });
+    }
+  );
+
   describe('warnings', () => {
     // NOTE: This test generates SQL errors on the console because of
     // a hard-coded console.log() in the duckdb-wasm worker

package/src/databases/sqlserver/sqlserver.spec.ts

@@ -0,0 +1,395 @@
+/*
+ * Copyright Contributors to the Malloy project
+ * SPDX-License-Identifier: MIT
+ */
+
+import {RuntimeList} from '../../runtimes';
+import {describeIfDatabaseAvailable} from '../../util';
+import '@malloydata/malloy/test/matchers';
+import {wrapTestModel} from '@malloydata/malloy/test';
+
+const [describe] = describeIfDatabaseAvailable(['sqlserver']);
+
+/*
+ * The dialect is built up here in the order a query grows: a literal, a
+ * table, a filter, an ordering, a grouping, a join. Each block is what the
+ * next one stands on, and what the cross-dialect suite in ../all assumes.
+ */
+describe('SQL Server', () => {
+  const runtimes = new RuntimeList(['sqlserver']);
+  const runtime = runtimes.runtimeMap.get('sqlserver');
+  if (runtime === undefined) {
+    throw new Error("Couldn't build runtime");
+  }
+  // A test runtime enables experimental dialects; no compiler flag is needed
+  const tm = wrapTestModel(runtime, '');
+
+  afterAll(async () => {
+    await runtimes.closeAll();
+  });
+
+  describe('a SQL block', () => {
+    test('selects a literal', async () => {
+      await expect(
+        'run: sqlserver.sql("SELECT 1 AS n") -> { select: n }'
+      ).toMatchResult(tm, {n: 1});
+    });
+
+    test('carries string, date and timestamp values', async () => {
+      await expect(`
+        run: sqlserver.sql("""
+          SELECT N'héllo' AS s,
+                 CAST('2021-02-24' AS DATE) AS d,
+                 CAST('2021-02-24 03:05:06' AS DATETIME2) AS t
+        """) -> { select: s, d, t }
+      `).toMatchResult(tm, {
+        s: 'héllo',
+        d: new Date('2021-02-24T00:00:00Z'),
+        t: new Date('2021-02-24T03:05:06Z'),
+      });
+    });
+
+    test('carries a newline in a string literal', async () => {
+      await expect(`
+        run: sqlserver.sql("SELECT 1 AS n") -> { select: s is 'a\\nb' }
+      `).toMatchResult(tm, {s: 'a\nb'});
+    });
+
+    test('quotes a field named like a keyword', async () => {
+      await expect(`
+        run: sqlserver.sql('SELECT 1 AS "select"') -> {
+          select: \`select\`, \`create\` is \`select\` + 1
+        }
+      `).toMatchResult(tm, {select: 1, create: 2});
+    });
+  });
+
+  describe('a table', () => {
+    test('a boolean literal is a condition', async () => {
+      await expect(`
+        run: sqlserver.table('malloytest.state_facts') -> {
+          where: true
+          aggregate: n is count(), none is count() { where: false }
+        }
+      `).toEqualResult(tm, [{n: 51, none: 0}]);
+    });
+
+    test('a bit column is an integer', async () => {
+      await expect(`
+        run: sqlserver.table('malloytest.alltypes') -> {
+          select: t_bool_true, t_bool_false, t_bool_null
+        }
+      `).toEqualResult(tm, [
+        {t_bool_true: 1, t_bool_false: 0, t_bool_null: null},
+      ]);
+    });
+
+    test('a limit of zero is no limit', async () => {
+      // FETCH NEXT 0 ROWS is a parse error; the compiler writes no limit at all
+      await expect(`
+        run: sqlserver.table('malloytest.state_facts') -> {
+          select: state
+          limit: 0
+        } -> { aggregate: n is count() }
+      `).toEqualResult(tm, [{n: 51}]);
+    });
+
+    test('a declared boolean is a 0/1 value', async () => {
+      await expect(`
+        run: sqlserver.table('malloytest.state_facts') -> {
+          group_by:
+            big is airport_count > 500
+            c_state is starts_with(state, 'C')
+          aggregate: n is count()
+          order_by: big desc, c_state desc
+        }
+      `).toEqualResult(tm, [
+        {big: true, c_state: true, n: 1},
+        {big: true, c_state: false, n: 11},
+        {big: false, c_state: true, n: 2},
+        {big: false, c_state: false, n: 37},
+      ]);
+    });
+
+    test('a cast to boolean is refused', async () => {
+      await expect(
+        runtime
+          .loadQuery(
+            `run: sqlserver.table('malloytest.state_facts') -> {
+              select: b is airport_count::boolean
+            }`
+          )
+          .run()
+      ).rejects.toThrow(/boolean/);
+    });
+
+    test('starts_with and ends_with are conditions', async () => {
+      await expect(`
+        run: sqlserver.table('malloytest.state_facts') -> {
+          aggregate:
+            c_states is count() { where: starts_with(state, 'C') }
+            a_states is count() { where: ends_with(state, 'A') }
+            nan_counts is count() { where: is_nan(airport_count) }
+        }
+      `).toEqualResult(tm, [{c_states: 3, a_states: 8, nan_counts: 0}]);
+    });
+
+    test('reads a column', async () => {
+      await expect(`
+        run: sqlserver.table('malloytest.state_facts') -> {
+          select: state
+          where: state = 'CA'
+        }
+      `).toEqualResult(tm, [{state: 'CA'}]);
+    });
+
+    test('reads a bracket-quoted path', async () => {
+      await expect(`
+        run: sqlserver.table('[malloytest].[state_facts]') -> {
+          select: state
+          where: state = 'CA'
+        }
+      `).toEqualResult(tm, [{state: 'CA'}]);
+    });
+
+    test('reads a database-qualified path', async () => {
+      await expect(`
+        run: sqlserver.table('malloytest.malloytest.state_facts') -> {
+          aggregate: n is count()
+        }
+      `).toMatchResult(tm, {n: 51});
+    });
+
+    test('orders and limits', async () => {
+      await expect(`
+        run: sqlserver.table('malloytest.state_facts') -> {
+          select: state
+          order_by: state desc
+          limit: 2
+        }
+      `).toEqualResult(tm, [{state: 'WY'}, {state: 'WV'}]);
+    });
+
+    test('limits a stage that feeds another', async () => {
+      await expect(`
+        run: sqlserver.table('malloytest.state_facts') -> {
+          select: state
+          order_by: state desc
+          limit: 3
+        } -> {
+          select: state
+          order_by: state asc
+        }
+      `).toEqualResult(tm, [{state: 'WI'}, {state: 'WV'}, {state: 'WY'}]);
+    });
+
+    test('filters on a comparison', async () => {
+      await expect(`
+        run: sqlserver.table('malloytest.state_facts') -> {
+          aggregate: n is count()
+          where: airport_count > 500
+        }
+      `).toMatchResult(tm, {n: 12});
+    });
+
+    test('escapes a bracket in a LIKE pattern', async () => {
+      await expect(`
+        run: sqlserver.sql("""
+          SELECT s FROM (VALUES (N'a[b'), (N'ab'), (N'axb')) v(s)
+        """) -> { select: s; where: s ~ 'a[%' }
+      `).toEqualResult(tm, [{s: 'a[b'}]);
+    });
+  });
+
+  describe('aggregation', () => {
+    test('a group of only constants is one row', async () => {
+      await expect(`
+        run: sqlserver.table('malloytest.state_facts') -> { group_by: x is 1, y is 'a' }
+      `).toEqualResult(tm, [{x: 1, y: 'a'}]);
+    });
+
+    test('a constant dimension groups with the others', async () => {
+      await expect(`
+        run: sqlserver.table('malloytest.state_facts') -> {
+          group_by: tag is 'facts', big is airport_count > 500
+          aggregate: n is count()
+          order_by: big desc
+        }
+      `).toEqualResult(tm, [
+        {tag: 'facts', big: true, n: 12},
+        {tag: 'facts', big: false, n: 39},
+      ]);
+    });
+
+    test('counts without a group', async () => {
+      await expect(`
+        run: sqlserver.table('malloytest.state_facts') -> {
+          aggregate: state_count is count()
+        }
+      `).toMatchResult(tm, {state_count: 51});
+    });
+
+    test('groups by a column', async () => {
+      await expect(`
+        run: sqlserver.table('malloytest.state_facts') -> {
+          group_by: popular_name
+          aggregate: state_count is count()
+          order_by: state_count desc
+        }
+      `).toMatchResult(tm, {popular_name: 'Isabella'});
+    });
+
+    test('groups by an expression', async () => {
+      await expect(`
+        run: sqlserver.table('malloytest.state_facts') -> {
+          group_by: first is substr(state, 1, 1)
+          aggregate: state_count is count()
+          order_by: state_count desc, first
+        }
+      `).toMatchResult(tm, {first: 'M', state_count: 8});
+    });
+
+    test('orders and limits a grouped result', async () => {
+      await expect(`
+        run: sqlserver.table('malloytest.state_facts') -> {
+          group_by: popular_name
+          aggregate: state_count is count()
+          order_by: state_count desc, popular_name
+          limit: 2
+        }
+      `).toEqualResult(tm, [
+        {popular_name: 'Isabella', state_count: 24},
+        {popular_name: 'Sophia', state_count: 11},
+      ]);
+    });
+
+    test('orders a query used as a source', async () => {
+      await expect(`
+        source: by_name is sqlserver.table('malloytest.state_facts') -> {
+          group_by: popular_name
+          aggregate: state_count is count()
+          order_by: state_count desc
+        }
+        run: by_name -> {
+          select: popular_name
+          where: state_count > 10
+          order_by: popular_name
+        }
+      `).toEqualResult(tm, [
+        {popular_name: 'Isabella'},
+        {popular_name: 'Sophia'},
+      ]);
+    });
+
+    test('orders the last stage of a pipeline', async () => {
+      await expect(`
+        run: sqlserver.table('malloytest.state_facts') -> {
+          group_by: popular_name
+          aggregate: state_count is count()
+        } -> {
+          select: popular_name, state_count
+          order_by: state_count asc, popular_name desc
+          limit: 2
+        }
+      `).toEqualResult(tm, [
+        {popular_name: 'Madison', state_count: 3},
+        {popular_name: 'Ava', state_count: 3},
+      ]);
+    });
+
+    test('divides as a float', async () => {
+      await expect(`
+        run: sqlserver.sql("SELECT 7 AS a, 2 AS b") -> {
+          select: q is a / b
+        }
+      `).toMatchResult(tm, {q: 3.5});
+    });
+  });
+
+  describe('functions', () => {
+    test('pow computes in floating point', async () => {
+      await expect(`
+        run: sqlserver.sql("SELECT 1 AS n") -> {
+          select: root is round(pow(2, 0.5), 6), hundredth is pow(10, -2)
+        }
+      `).toEqualResult(tm, [{root: 1.414214, hundredth: 0.01}]);
+    });
+
+    test('length counts trailing spaces', async () => {
+      await expect(`
+        run: sqlserver.sql("SELECT 1 AS n") -> {
+          select:
+            padded is length('abc  ')
+            back is substr('abc ', -2)
+        }
+      `).toEqualResult(tm, [{padded: 5, back: 'c '}]);
+    });
+  });
+
+  describe('time zones', () => {
+    test('converts a query time zone through its Windows name', async () => {
+      await expect(`
+        run: sqlserver.sql("SELECT CAST('2020-02-20 00:00:00' AS DATETIME2) AS t") -> {
+          timezone: 'America/Mexico_City'
+          select: mex_day is t.day, mex_hour is hour(t)
+        }
+      `).toMatchResult(tm, {
+        mex_day: new Date('2020-02-19T06:00:00Z'),
+        mex_hour: 18,
+      });
+    });
+
+    test('a zone is known by its current IANA name as well as its old one', async () => {
+      await expect(`
+        run: sqlserver.sql("SELECT CAST('2021-02-24 03:05:06' AS DATETIME2) AS t") -> {
+          timezone: 'Asia/Kolkata'
+          select: h is hour(t)
+        }
+      `).toEqualResult(tm, [{h: 8}]);
+      await expect(`
+        run: sqlserver.sql("SELECT CAST('2021-02-24 03:05:06' AS DATETIME2) AS t") -> {
+          timezone: 'Europe/Kyiv'
+          select: h is hour(t)
+        }
+      `).toEqualResult(tm, [{h: 5}]);
+    });
+
+    test('a literal written in a zone is that instant', async () => {
+      await expect(`
+        run: sqlserver.sql("SELECT 1 AS n") -> {
+          select: t is @2020-02-20 00:00:00[America/Mexico_City]
+        }
+      `).toMatchResult(tm, {t: new Date('2020-02-20T06:00:00Z')});
+    });
+  });
+
+  describe('joins', () => {
+    test('sums each side of a fan-out once', async () => {
+      await expect(`
+        source: facts is sqlserver.table('malloytest.state_facts')
+        run: facts extend { join_cross: other is facts on other.state = 'CA' | 'NY' } -> {
+          aggregate:
+            row_count is count(concat(state, other.state))
+            left_sum is airport_count.sum()
+            right_sum is other.airport_count.sum()
+        }
+      `).toMatchResult(tm, {row_count: 102, left_sum: 19701, right_sum: 1560});
+    });
+
+    test('joins and aggregates symmetrically', async () => {
+      await expect(`
+        source: carriers is sqlserver.table('malloytest.carriers') extend {
+          primary_key: code
+        }
+        source: flights is sqlserver.table('malloytest.flights') extend {
+          join_one: carriers with carrier
+        }
+        run: flights -> {
+          group_by: carriers.nickname
+          aggregate: flight_count is count(), carrier_count is carriers.count()
+          order_by: flight_count desc
+        }
+      `).toMatchResult(tm, {nickname: 'Southwest', carrier_count: 1});
+    });
+  });
+});

package/src/runtimes.ts

@@ -16,6 +16,7 @@ import {
   InMemoryURLReader,
   InMemoryModelCache,
   CacheManager,
+  getDialect,
 } from '@malloydata/malloy';
 import {createTestRuntime} from '@malloydata/malloy/test';
 import {BigQueryConnection} from '@malloydata/db-bigquery';
@@ -31,6 +32,10 @@ import {
   MySQLExecutor,
 } from '@malloydata/db-mysql/src/mysql_connection';
 import {DatabricksConnection} from '@malloydata/db-databricks/src/databricks_connection';
+import {
+  SQLServerConnection,
+  SQLServerExecutor,
+} from '@malloydata/db-sqlserver/src/sqlserver_connection';
 import {EventEmitter} from 'events';
 
 export class SnowflakeTestConnection extends SnowflakeConnection {
@@ -144,6 +149,21 @@ export class DuckDBWASMTestConnection extends DuckDBWASMConnection {
   }
 }
 
+export class SQLServerTestConnection extends SQLServerConnection {
+  public async runSQL(
+    sqlCommand: string,
+    options?: RunSQLOptions
+  ): Promise<MalloyQueryData> {
+    try {
+      return await super.runSQL(sqlCommand, options);
+    } catch (e) {
+      // eslint-disable-next-line no-console
+      console.log(`Error in SQL:\n ${sqlCommand}`);
+      throw e;
+    }
+  }
+}
+
 export class TestCacheManager extends CacheManager {
   constructor(readonly _modelCache: ModelCache) {
     super(_modelCache);
@@ -203,14 +223,26 @@ export function runtimeFor(dbName: string): SingleConnectionRuntime {
         );
         break;
       case 'mssql_via_duckdb':
-        connection = new DuckDBTestConnection({
-          name: dbName,
-          additionalExtensions: ['mssql'],
-          setupSQL: [
-            "ATTACH 'Server=localhost;Port=1433;Database=malloytest;User Id=sa;Password=Malloy_Test_123;TrustServerCertificate=true' AS msdb (TYPE mssql)",
-            'USE msdb.malloytest',
-          ].join(';\n'),
-        });
+        {
+          const s = SQLServerExecutor.getConnectionOptionsFromEnv();
+          if (s.server === undefined) {
+            throw new Error(
+              'MSSQL_HOST is not set; see test/mssql/mssql_start.sh'
+            );
+          }
+          connection = new DuckDBTestConnection({
+            name: dbName,
+            additionalExtensions: ['mssql'],
+            setupSQL: [
+              // The same string test/mssql/connection_string.ts builds for the
+              // loader, written here because packages/malloy-render type-checks
+              // this file alone and admits no import beside it. `Server=host,port`:
+              // the extension reads no separate Port key.
+              `ATTACH 'Server=${s.server},${s.port ?? 1433};Database=${s.database};User Id=${s.user};Password=${s.password};TrustServerCertificate=${s.trustServerCertificate ?? false}' AS msdb (TYPE mssql)`,
+              `USE msdb.${s.database}`,
+            ].join(';\n'),
+          });
+        }
         break;
       case 'motherduck':
         connection = new DuckDBTestConnection({
@@ -246,6 +278,12 @@ export function runtimeFor(dbName: string): SingleConnectionRuntime {
           TrinoExecutor.getConnectionOptionsFromEnv(dbName) // they share configs.
         );
         break;
+      case 'sqlserver':
+        connection = new SQLServerTestConnection(
+          dbName,
+          SQLServerExecutor.getConnectionOptionsFromEnv()
+        );
+        break;
       case 'databricks':
         {
           const warehouseId = process.env['DATABRICKS_WAREHOUSE_ID'];
@@ -264,6 +302,9 @@ export function runtimeFor(dbName: string): SingleConnectionRuntime {
       default:
         throw new Error(`Unknown runtime "${dbName}`);
     }
+    // The shared suites carry no `##! experimental.dialect.NAME` lines. A
+    // dialect under test is accepted once, for the whole process, instead.
+    getDialect(connection.dialectName).acceptExperimental();
     return testRuntimeFor(connection);
   } catch (error) {
     throw new Error(
@@ -313,7 +354,6 @@ export class RuntimeList {
         database instanceof SingleConnectionRuntime
           ? database
           : runtimeFor(database);
-      rt.isTestRuntime = true;
       this.runtimeMap.set(rt.connection.name, rt);
       this.runtimeList.push([rt.connection.name, rt]);
     }

package/src/test-select.ts

@@ -521,21 +521,17 @@ export class TestSelect {
     const innerQuery = selects.join('\nUNION ALL ');
 
     // Generate ORDER BY based on dialect preference
-    let orderByClause: string;
-    if (this.dialect.orderByClause === 'ordinal') {
-      // ORDER BY position (column count + 1 since row_id is last)
-      orderByClause = `ORDER BY ${columnList.length + 1}`;
-    } else if (this.dialect.orderByClause === 'output_name') {
-      // ORDER BY column name
-      orderByClause = `ORDER BY ${rowIdColumn}`;
-    } else {
-      // ORDER BY expression - just use column name (qualified would be t_sorted.__ts_row_id__)
-      orderByClause = `ORDER BY ${rowIdColumn}`;
-    }
-    // Presto/Trino ignores ORDER BY on a subquery without LIMIT
-    orderByClause += ` LIMIT ${rows.length}`;
+    const orderTerm =
+      this.dialect.orderByClause === 'ordinal'
+        ? `${columnList.length + 1}`
+        : rowIdColumn;
+    // Presto/Trino ignores ORDER BY on a subquery without a row limit
+    const orderByClause = this.dialect.sqlOrderByLimit(
+      [orderTerm],
+      rows.length
+    );
 
-    const sql = `SELECT ${quotedColumns}\nFROM (\n  SELECT *\n  FROM (\n${innerQuery}\n  ) AS t_sorted\n  ${orderByClause}\n) AS t_result\n`;
+    const sql = `SELECT ${quotedColumns}\nFROM (\n  SELECT *\n  FROM (\n${innerQuery}\n  ) AS t_sorted\n  ${orderByClause}) AS t_result\n`;
 
     return sql;
   }

package/trino/hive.properties

@@ -0,0 +1,11 @@
+# The hive catalog serves test/data/malloytest-parquet, mounted read-only
+# under /data/malloytest, with the tables hive_ddl.ts declares. The file
+# metastore lives inside the container's own data directory, which the trino
+# user can write; nothing but the parquet crosses the container boundary.
+connector.name=hive
+hive.metastore=file
+hive.metastore.catalog.dir=local:///trino/metastore
+fs.native-local.enabled=true
+local.location=/data
+# The parquet timestamps are microseconds; the DDL declares TIMESTAMP(6)
+hive.timestamp-precision=MICROSECONDS