Fix: drop table statement

.gitignore

@@ -12,3 +12,4 @@ system-test/*key.json
 .DS_Store
 package-lock.json
 __pycache__
+.vscode

src/database.ts

@@ -133,6 +133,10 @@
   ): SessionPoolInterface;
 }
 
+export type GetDatabaseDialectCallback = NormalCallback<
+  EnumKey<typeof google.spanner.admin.database.v1.DatabaseDialect>
+>;
+
 export interface SetIamPolicyRequest {
   policy: Policy | null;
   updateMask?: FieldMask | null;
@@ -166,7 +170,15 @@
     typeof databaseAdmin.spanner.admin.database.v1.Database.State
   >,
   'restoreInfo'
-> & {restoreInfo?: IRestoreInfoTranslatedEnum | null};
+> &
+  Omit<
+    TranslateEnumKeys<
+      databaseAdmin.spanner.admin.database.v1.IDatabase,
+      'databaseDialect',
+      typeof databaseAdmin.spanner.admin.database.v1.DatabaseDialect
+    >,
+    'restoreInfo'
+  > & {restoreInfo?: IRestoreInfoTranslatedEnum | null};
 
 /**
  * IRestoreInfo structure with restore source type enum translated to string form.
@@ -312,6 +324,9 @@
   resourceHeader_: {[k: string]: string};
   request: DatabaseRequest;
   databaseRole?: string | null;
+  databaseDialect?: EnumKey<
+    typeof databaseAdmin.spanner.admin.database.v1.DatabaseDialect
+  > | null;
   constructor(
     instance: Instance,
     name: string,
@@ -1476,6 +1491,61 @@
     return metadata.state || undefined;
   }
 
+  /**
+   * Retrieves the dialect of the database
+   *
+   * @see {@link #getMetadata}
+   *
+   * @method Database#getDatabaseDialect
+   *
+   * @param {object} [gaxOptions] Request configuration options,
+   *     See {@link https://googleapis.dev/nodejs/google-gax/latest/interfaces/CallOptions.html|CallOptions}
+   *     for more details.
+   * @param {GetDatabaseDialectCallback} [callback] Callback function.
+   * @returns {Promise<EnumKey<typeof, databaseAdmin.spanner.admin.database.v1.DatabaseDialect> | undefined>}
+   * When resolved, contains the database dialect of the database if the dialect is defined.
+   * @example
+   * const {Spanner} = require('@google-cloud/spanner');
+   * const spanner = new Spanner();
+   * const instance = spanner.instance('my-instance');
+   * const database = instance.database('my-database');
+   * const dialect = await database.getDatabaseDialect();
+   * const isGoogleSQL = (dialect === 'GOOGLE_STANDARD_SQL');
+   * const isPostgreSQL = (dialect === 'POSTGRESQL');
+   */
+
+  getDatabaseDialect(
+    options?: CallOptions
+  ): Promise<
+    | EnumKey<typeof databaseAdmin.spanner.admin.database.v1.DatabaseDialect>
+    | undefined
+  >;
+  getDatabaseDialect(callback: GetDatabaseDialectCallback): void;
+  getDatabaseDialect(
+    options: CallOptions,
+    callback: GetDatabaseDialectCallback
+  ): void;
+  async getDatabaseDialect(
+    optionsOrCallback?: CallOptions | GetDatabaseDialectCallback,
+    cb?: GetDatabaseDialectCallback
+  ): Promise<
+    | EnumKey<typeof databaseAdmin.spanner.admin.database.v1.DatabaseDialect>
+    | undefined
+  > {
+    const gaxOptions =
+      typeof optionsOrCallback === 'object' ? optionsOrCallback : {};
+
+    if (
+      this.databaseDialect === 'DATABASE_DIALECT_UNSPECIFIED' ||
+      this.databaseDialect === null ||
+      this.databaseDialect === undefined
+    ) {
+      const [metadata] = await this.getMetadata(gaxOptions);
+      this.databaseDialect = metadata.databaseDialect;
+    }
+    return this.databaseDialect || undefined;
+  }
+
   /**
    * @typedef {array} GetSchemaResponse
    * @property {string[]} 0 An array of database DDL statements.
@@ -3429,6 +3499,7 @@
     'batchTransaction',
     'getRestoreInfo',
     'getState',
+    'getDatabaseDialect',
     'getOperations',
     'runTransaction',
     'runTransactionAsync',

src/table.ts

@@ -68,6 +68,8 @@ export type UpsertRowsCallback = CommitCallback;
 export type UpsertRowsResponse = CommitResponse;
 export type UpsertRowsOptions = MutateRowsOptions;
 
+const GOOGLE_STANDARD_SQL = 'GOOGLE_STANDARD_SQL';
+const POSTGRESQL = 'POSTGRESQL';
 /**
  * Create a Table object to interact with a table in a Cloud Spanner
  * database.
@@ -342,11 +344,37 @@ class Table {
     const callback =
       typeof gaxOptionsOrCallback === 'function' ? gaxOptionsOrCallback : cb!;
 
-    return this.database.updateSchema(
-      'DROP TABLE `' + this.name + '`',
-      gaxOptions,
-      callback!
-    );
+    const [schema, table] = this.name.includes('.')
+      ? this.name.split('.')
+      : [null, this.name];
+
+    let dropStatement = 'DROP TABLE `' + table + '`';
+
+    const performDelete = async (): Promise<void | DropTableResponse> => {
+      const result = await this.database.getDatabaseDialect(gaxOptions);
+
+      if (result && result.includes(POSTGRESQL)) {
+        dropStatement = schema
+          ? `DROP TABLE "${schema}"."${table}"`
+          : `DROP TABLE "${table}"`;
+      } else if (result && result.includes(GOOGLE_STANDARD_SQL)) {
+        dropStatement = schema
+          ? 'DROP TABLE `' + schema + '`.`' + table + '`'
+          : dropStatement;
+      }
+
+      const updateSchemaResult = callback
+        ? this.database.updateSchema(dropStatement, gaxOptions, callback)
+        : this.database.updateSchema(dropStatement, gaxOptions);
+
+      return updateSchemaResult as Promise<DropTableResponse | void>;
+    };
+
+    if (!callback) {
+      return performDelete() as Promise<DropTableResponse>;
+    } else {
+      performDelete();
+    }
   }
   /**
    * @typedef {array} DeleteRowsResponse

test/database.ts

@@ -52,6 +52,7 @@ const fakePfy = extend({}, pfy, {
       'batchTransaction',
       'getRestoreInfo',
       'getState',
+      'getDatabaseDialect',
       'getOperations',
       'runTransaction',
       'runTransactionAsync',
@@ -2795,6 +2796,35 @@ describe('Database', () => {
     });
   });
 
+  describe('getDatabaseDialect', () => {
+    it('should get database dialect from database metadata', async () => {
+      database.getMetadata = async () => [
+        {databaseDialect: 'GOOGLE_STANDARD_SQL'},
+      ];
+      const result = await database.getDatabaseDialect();
+      assert.strictEqual(result, 'GOOGLE_STANDARD_SQL');
+    });
+
+    it('should accept and pass gaxOptions to getMetadata', async () => {
+      const options = {};
+      database.getMetadata = async gaxOptions => {
+        assert.strictEqual(gaxOptions, options);
+        return [{}];
+      };
+      await database.getDatabaseDialect(options);
+    });
+
+    it('should accept callback and return database dialect', done => {
+      const databaseDialect = 'GOOGLE_STANDARD_SQL';
+      database.getMetadata = async () => [{databaseDialect}];
+      database.getDatabaseDialect((err, result) => {
+        assert.ifError(err);
+        assert.strictEqual(result, databaseDialect);
+        done();
+      });
+    });
+  });
+
   describe('getRestoreInfo', () => {
     it('should get restore info from database metadata', async () => {
       const restoreInfo = {sourceType: 'BACKUP'};

test/table.ts

@@ -67,6 +67,7 @@ describe('Table', () => {
   // eslint-disable-next-line @typescript-eslint/no-explicit-any
   let TableCached: any;
   let table;
+  let tableWithSchema;
   let transaction: FakeTransaction;
 
   const DATABASE = {
@@ -75,6 +76,7 @@ describe('Table', () => {
   };
 
   const NAME = 'table-name';
+  const NAMEWITHSCHEMA = 'schema.' + NAME;
 
   before(() => {
     Table = proxyquire('../src/table.js', {
@@ -86,6 +88,7 @@ describe('Table', () => {
   beforeEach(() => {
     extend(Table, TableCached);
     table = new Table(DATABASE, NAME);
+    tableWithSchema = new Table(DATABASE, NAMEWITHSCHEMA);
     transaction = new FakeTransaction();
   });
 
@@ -209,26 +212,124 @@ describe('Table', () => {
   });
 
   describe('delete', () => {
-    it('should update the schema on the database', () => {
-      const updateSchemaReturnValue = {};
+    it('should update the schema on the database for GoogleSQL using await', async () => {
+      table.database = {
+        getDatabaseDialect: () => {
+          return 'GOOGLE_STANDARD_SQL';
+        },
+        updateSchema: schema => {
+          assert.strictEqual(schema, 'DROP TABLE `table-name`');
+        },
+      };
+
+      await table.delete();
+    });
+
+    it('should update the schema on the database for GoogleSQL using callbacks', () => {
+      function callback() {}
+      table.database = {
+        getDatabaseDialect: () => {
+          return 'GOOGLE_STANDARD_SQL';
+        },
+        updateSchema: (schema, gaxOptions, callback_) => {
+          assert.strictEqual(schema, 'DROP TABLE `table-name`');
+          assert.strictEqual(callback_, callback);
+        },
+      };
+      table.delete(callback);
+    });
+
+    it('should update the schema on the database for GoogleSQL with schema in the table name using await', async () => {
+      tableWithSchema.database = {
+        getDatabaseDialect: () => {
+          return 'GOOGLE_STANDARD_SQL';
+        },
+        updateSchema: schema => {
+          assert.strictEqual(schema, 'DROP TABLE `schema`.`table-name`');
+        },
+      };
+
+      await tableWithSchema.delete();
+    });
+
+    it('should update the schema on the database for GoogleSQL with schema in the table name using callbacks', () => {
+      function callback() {}
+      tableWithSchema.database = {
+        getDatabaseDialect: () => {
+          return 'GOOGLE_STANDARD_SQL';
+        },
+        updateSchema: (schema, gaxOptions, callback_) => {
+          assert.strictEqual(schema, 'DROP TABLE `schema`.`table-name`');
+          assert.strictEqual(callback_, callback);
+        },
+      };
+      tableWithSchema.delete(callback);
+    });
+
+    it('should update the schema on the database for PostgresSQL using await', async () => {
+      table.database = {
+        getDatabaseDialect: () => {
+          return 'POSTGRESQL';
+        },
+        updateSchema: schema => {
+          assert.strictEqual(schema, `DROP TABLE "${table.name}"`);
+        },
+      };
 
+      await table.delete();
+    });
+
+    it('should update the schema on the database for PostgresSQL using callbacks', () => {
       function callback() {}
 
       table.database = {
+        getDatabaseDialect: () => {
+          return 'POSTGRESQL';
+        },
         updateSchema: (schema, gaxOptions, callback_) => {
-          assert.strictEqual(schema, 'DROP TABLE `' + table.name + '`');
+          assert.strictEqual(schema, 'DROP TABLE "table-name"');
           assert.strictEqual(callback_, callback);
-          return updateSchemaReturnValue;
         },
       };
 
-      const returnValue = table.delete(callback);
-      assert.strictEqual(returnValue, updateSchemaReturnValue);
+      table.delete(callback);
+    });
+
+    it('should update the schema on the database for PostgresSQL with schema in the table name using await', async () => {
+      tableWithSchema.database = {
+        getDatabaseDialect: () => {
+          return 'POSTGRESQL';
+        },
+        updateSchema: schema => {
+          assert.strictEqual(schema, `DROP TABLE "schema"."${table.name}"`);
+        },
+      };
+
+      await tableWithSchema.delete();
+    });
+
+    it('should update the schema on the database for PostgresSQL with schema in the table name using callbacks', () => {
+      function callback() {}
+      tableWithSchema.database = {
+        getDatabaseDialect: () => {
+          return 'POSTGRESQL';
+        },
+        updateSchema: (schema, gaxOptions, callback_) => {
+          assert.strictEqual(schema, `DROP TABLE "schema"."${table.name}"`);
+          assert.strictEqual(callback_, callback);
+        },
+      };
+
+      tableWithSchema.delete(callback);
     });
 
     it('should accept and pass gaxOptions to updateSchema', done => {
       const gaxOptions = {};
       table.database = {
+        getDatabaseDialect: gaxOptionsFromTable => {
+          assert.strictEqual(gaxOptionsFromTable, gaxOptions);
+          return 'GOOGLE_STANDARD_SQL';
+        },
         updateSchema: (schema, gaxOptionsFromTable) => {
           assert.strictEqual(gaxOptionsFromTable, gaxOptions);
           done();