Returns {@code true} if succeed to drop table, otherwise {@code false} is returned.

@param tableName
@return
1332
public boolean dropTableIfExists(final String tableName) {
        Connection conn = getConnection();

        try {
            return JdbcUtil.dropTableIfExists(conn, tableName);
        } finally {
            closeQuietly(conn);
        }
    }
986309
public VoltTable sortByAverage(String tableName)
    {
        List<ProcProfRow> sorted = new ArrayList<ProcProfRow>(m_table);
        Collections.sort(sorted, new Comparator<ProcProfRow>() {
            @Override
            public int compare(ProcProfRow lhs, ProcProfRow rhs) {
                return compareByAvg(rhs, lhs);  // sort desc
            }
        });

        long sumOfAverage = 0L;
        for (ProcProfRow row : sorted) {
            sumOfAverage += (row.avg * row.invocations);
        }

        VoltTable result = TableShorthand.tableFromShorthand(
                tableName + "(TIMESTAMP:BIGINT, PROCEDURE:VARCHAR, WEIGHTED_PERC:BIGINT, INVOCATIONS:BIGINT," +
                "AVG:BIGINT, MIN:BIGINT, MAX:BIGINT, ABORTS:BIGINT, FAILURES:BIGINT)");
        for (ProcProfRow row : sorted ) {
            result.addRow(row.timestamp, row.procedure, calculatePercent(row.avg * row.invocations, sumOfAverage),
                    row.invocations, row.avg, row.min, row.max, row.aborts, row.failures);
        }

        return result;
    }
438796
public int delete(String tableName) {
		DeleteBuilder<GriddedTile, Long> db = deleteBuilder();

		int deleted = 0;

		try {
			db.where().eq(GriddedTile.COLUMN_TABLE_NAME, tableName);

			PreparedDelete<GriddedTile> deleteQuery = db.prepare();
			deleted = delete(deleteQuery);
		} catch (SQLException e) {
			throw new GeoPackageException(
					"Failed to delete Gridded Tile by Table Name: " + tableName,
					e);
		}

		return deleted;
	}
963341
public function dropTable(string $tableName): bool
    {
        $this->db->exec(sprintf('DROP TABLE IF EXISTS %s;', $this->quoter->quoteName($tableName)));

        return true;
    }
74585
public boolean deleteTable(String datasetName, String tableName) {
    // [START ]
    boolean deleted = bigquery.delete(datasetName, tableName);
    if (deleted) {
      // the table was deleted
    } else {
      // the table was not found
    }
    // [END ]
    return deleted;
  }
601103
public Boolean deletes(String tableName, Set<byte[]> rowKeys) {
        boolean flag = false;
        try {
            HTable table = (HTable) getConnection().getTable(TableName.valueOf(tableName));
            List<Delete> deletes = new ArrayList<>();
            for (byte[] rowKey : rowKeys) {
                Delete delete = new Delete(rowKey);
                deletes.add(delete);
            }
            if (!deletes.isEmpty()) {
                table.delete(deletes);
            }
            flag = true;
        } catch (Exception e) {
            logger.error(e.getMessage(), e);
            throw new RuntimeException(e);
        }
        return flag;
    }
271675
public static String generateDropTableDDL(String dbName, String tableName) {
    return String.format("DROP TABLE IF EXISTS `%s`.`%s`", dbName, tableName);
  }
11584
public void delete(String tableName) {
		try {
			if (extensionsDao.isTableExists()) {
				List<Extensions> extensions = extensionsDao.queryByExtension(
						EXTENSION_NAME, tableName);
				for (Extensions extension : extensions) {
					delete(extension.getTableName(), extension.getColumnName());
				}
			}
		} catch (SQLException e) {
			throw new GeoPackageException(
					"Failed to delete RTree Index extensions for table. GeoPackage: "
							+ geoPackage.getName() + ", Table: " + tableName, e);
		}

	}
1108028
public static void drop(DB db, String tableName) {
    DBSetup.drop(CallInfo.create(), db, tableName);
  }
297365
protected function tableExists($tableName)
    {
        $tables = $this->connection->getSchemaManager()->listTables();

        foreach ($tables as $table) {
            if ($table->getName() == $tableName) {
                return true;
            }
        }

        return false;
    }
74248
public boolean isShardingColumn(final String columnName, final String tableName) {
        for (TableRule each : tableRules) {
            if (each.getLogicTable().equalsIgnoreCase(tableName) && isShardingColumn(each, columnName)) {
                return true;
            }
        }
        return false;
    }
818860
public boolean has(String tableName, String columnName) {
		return has(EXTENSION_NAME, tableName, columnName)
				&& connection.tableExists(getRTreeTableName(tableName,
						columnName));
	}
525679
public boolean removeTable(BaseTable table)
    {
        if (m_mapTable != null)
        {
            for (Object objKey : m_mapTable.keySet())
            {
                if (table == m_mapTable.get(objKey))
                {
                    return (m_mapTable.remove(objKey) != null);
                }                
            }
        }
        else
        {
            if (this.getNextTable() != null)
                return this.getNextTable().removeTable(table);
        }
        return super.removeTable(table);
    }
816012
public function deleteTable($tableName)
    {
        $deleteStatementStr = "DROP TABLE IF EXISTS {$this->db->platform->quoteIdentifier($tableName)}";
        $deleteStatement = $this->db->query($deleteStatementStr);

        return $deleteStatement->execute();
    }
883861
public boolean hasColumn(String columnName) {
        Integer idx = columnNamesIndex.get(columnName);
        return idx != null;
    }
1245804
@NonNull
  public static Drop dropTable(@Nullable String keyspace, @NonNull String tableName) {
    return dropTable(
        keyspace == null ? null : CqlIdentifier.fromCql(keyspace),
        CqlIdentifier.fromCql(tableName));
  }
1315364
public boolean hasMapping(String tableName, long baseId, long relatedId) {
		UserMappingDao userMappingDao = getMappingDao(tableName);
		return userMappingDao.countByIds(baseId, relatedId) > 0;
	}