Added schema function (#1432)

* Removed redundant toResolvable calls

* Refactored resolve/normalize in session

* Added schema function to common context objects

* Removed unused session import

* Bumped minor version

* Simplified schema assertions in core.spec.ts

* Refactored normalize* => finalize* in session helpers

* Refactored with/without suffix tests to run as parameterized tests

* Removed redundant 'Test' import

Author: a2wd

core/assertion.ts

@@ -202,7 +202,13 @@ export class AssertionContext implements ICommonContext {
   }
 
   public resolve(ref: Resolvable | string[], ...rest: string[]) {
-    return this.assertion.session.resolve(toResolvable(ref, rest));
+    return this.assertion.session.resolve(ref, ...rest);
+  }
+
+  public schema(): string {
+    return this.assertion.session.finalizeSchema(
+      this.assertion.proto.target.schema
+    );
   }
 
   public dependencies(name: Resolvable | Resolvable[]) {

core/common.ts

@@ -45,6 +45,11 @@ export interface ICommonContext {
    * See the `ref` function for example usage.
    */
   resolve: (ref: Resolvable | string[], ...rest: string[]) => string;
+
+  /**
+   * Returns the schema of this dataset.
+   */
+  schema: () => string;
 }
 
 /**
@@ -193,9 +198,9 @@ export interface IRecordDescriptor {
    *
    * These should be the fully qualified identifier of the tag, including the project name, location, and taxonomy,
    * which can be copied from the policy tags page in GCP.
-   * 
+   *
    * For example: "projects/1/locations/eu/taxonomies/2/policyTags/3"
-   * 
+   *
    * Currently BigQuery supports only a single tag per column.
    */
   bigqueryPolicyTags?: string | string[];

core/operation.ts

@@ -234,7 +234,13 @@ export class OperationContext implements ICommonContext {
   }
 
   public resolve(ref: Resolvable | string[], ...rest: string[]) {
-    return this.operation.session.resolve(toResolvable(ref, rest));
+    return this.operation.session.resolve(ref, ...rest);
+  }
+
+  public schema(): string {
+    return this.operation.session.finalizeSchema(
+      this.operation.proto.target.schema
+    );
   }
 
   public dependencies(name: Resolvable | Resolvable[]) {

core/session.ts

@@ -245,15 +245,9 @@ export class Session {
         ...resolved.proto.target,
         database:
           resolved.proto.target.database &&
-          this.adapter().normalizeIdentifier(
-            `${resolved.proto.target.database}${this.getDatabaseSuffixWithUnderscore()}`
-          ),
-        schema: this.adapter().normalizeIdentifier(
-          `${resolved.proto.target.schema}${this.getSchemaSuffixWithUnderscore()}`
-        ),
-        name: this.adapter().normalizeIdentifier(
-          `${this.getTablePrefixWithUnderscore()}${resolved.proto.target.name}`
-        )
+          this.finalizeDatabase(resolved.proto.target.database),
+        schema: this.finalizeSchema(resolved.proto.target.schema),
+        name: this.finalizeName(resolved.proto.target.name),
       });
     }
     // TODO: Here we allow 'ref' to go unresolved. This is for backwards compatibility with projects
@@ -266,27 +260,20 @@ export class Session {
         utils.target(
           this.adapter(),
           this.config,
-          this.adapter().normalizeIdentifier(`${this.getTablePrefixWithUnderscore()}${ref}`),
-          this.adapter().normalizeIdentifier(
-            `${this.config.defaultSchema}${this.getSchemaSuffixWithUnderscore()}`
-          ),
+          this.finalizeName(ref),
+          this.finalizeSchema(this.config.defaultSchema),
           this.config.defaultDatabase &&
-            this.adapter().normalizeIdentifier(
-              `${this.config.defaultDatabase}${this.getDatabaseSuffixWithUnderscore()}`
-            )
+            this.finalizeDatabase(this.config.defaultDatabase),
         )
       );
     }
     return this.adapter().resolveTarget(
       utils.target(
         this.adapter(),
         this.config,
-        this.adapter().normalizeIdentifier(`${this.getTablePrefixWithUnderscore()}${ref.name}`),
-        this.adapter().normalizeIdentifier(`${ref.schema}${this.getSchemaSuffixWithUnderscore()}`),
-        ref.database &&
-          this.adapter().normalizeIdentifier(
-            `${ref.database}${this.getDatabaseSuffixWithUnderscore()}`
-          )
+        this.finalizeName(ref.name),
+        this.finalizeSchema(ref.schema),
+        ref.database && this.finalizeName(ref.database),
       )
     );
   }
@@ -444,6 +431,21 @@ export class Session {
     return encode64(dataform.CompiledGraph, this.compile());
   }
 
+  public finalizeDatabase(database: string): string {
+    return this.adapter().normalizeIdentifier(
+      `${database}${this.getDatabaseSuffixWithUnderscore()}`);
+  }
+
+  public finalizeSchema(schema: string): string {
+    return this.adapter().normalizeIdentifier(
+      `${schema}${this.getSchemaSuffixWithUnderscore()}`);
+  }
+
+  public finalizeName(name: string): string {
+    return this.adapter().normalizeIdentifier(
+      `${this.getTablePrefixWithUnderscore()}${name}`);
+  }
+
   private getDatabaseSuffixWithUnderscore() {
     return !!this.config.databaseSuffix ? `_${this.config.databaseSuffix}` : "";
   }

core/table.ts

@@ -787,7 +787,11 @@ export class TableContext implements ITableContext {
   }
 
   public resolve(ref: Resolvable | string[], ...rest: string[]) {
-    return this.table.session.resolve(toResolvable(ref, rest));
+    return this.table.session.resolve(ref, ...rest);
+  }
+
+  public schema(): string {
+    return this.table.session.finalizeSchema(this.table.proto.target.schema);
   }
 
   public type(type: TableType) {

core/test.ts

@@ -178,6 +178,10 @@ class RefReplacingContext implements ITableContext {
     return "";
   }
 
+  public schema() {
+    return "";
+  }
+
   public where(where: Contextable<ITableContext, string>) {
     return "";
   }