Full Application

Snippet

MongoDB

Partner

Student

Community

Introductory

Advanced

Jasiek Petryk

Here at [Scale Up](https://scaleup.com.pl/), we value music a lot. We have a Google Home speaker at our office that gets a lot of use. Music gets us going and helps us express ourselves individually as well as an organization. With how important music is in our lives, an idea came to our minds: We wanted to share what we like to listen to. We made [a Scale Up Spotify playlist](https://open.spotify.com/playlist/5oB8RrrUTu1Ulyw2995IcD?si=0a27142f344841aa) that we share on our website and listen to quite often, but we wanted to take it one step further. We wanted a way for others to be able to see what we're currently listening to in the office, and to host that, we turned to Atlas Application Services. 

Sources of music and ways to connect to the speaker are varied. Some people listen on YouTube, others on Spotify, some like to connect via a Cast feature that Google Home provides, and others just use Bluetooth connection to play the tunes. We sometimes use the voice features of Google Home and politely ask the speaker to put some music on.

All of this means that there's no easily available "one source of truth" for what's currently playing on the speaker. We could try to somehow connect to Spotify or Google Home's APIs to see what's being cast, but that doesn’t cover all the aforementioned cases—connecting via Bluetooth or streaming from YouTube. The only real source of truth is what our ears can actually hear. 

That's what we ultimately landed on—trying to figure out what song is playing by actually listening to soundwaves coming out of the speaker. Thankfully, there are [a lot of public APIs](https://rapidapi.com/collection/shazam-api) that can recognize songs based on a short audio sample. We decided to pick one that's pretty accurate when it comes to Polish music. In the end, it’s a big part of what we're listening to.

![Debugging application on an old and beaten up Nexus 5](https://mongodb-devhub-cms.s3.us-west-1.amazonaws.com/debugging_application_nexus_5_2006fefe5e.png)

All of this has to run somewhere. The first thing that came to mind was to build this "listening device" by getting a Raspberry Pi with a microphone, but after going through my "old tech drawer"—let's face it, all of us techies have one—I found an old Nexus 5. After playing with some custom ROMs, I managed to run node.js applications there. If you think about it, it really is a perfect device for this use case. It has more than enough computing power, a built-in microphone, and a screen just in case you need to do a quick debug. I ended up writing a small program that takes a short audio sample every couple of minutes between 7:00 am and 5:00 pm and uses the API mentioned above to recognize the song.

The piece of information about what we're currently listening to is a good starting point, but in order to embed it on our website, we need to store it somewhere first. Here's where MongoDB's and Mongo Atlas' powers come into play. Setting up a cloud database was very easy. It took me less than five minutes. The free tier is more than enough for prototyping and simple use cases like this one, and if you end up needing more, you can always switch to a higher tier. I connected my application to a MongoDB Atlas instance using the [MongoDB Node Driver](https://www.mongodb.com/docs/drivers/node/current/).

Now that we have information about what's currently playing captured and safely stored in the MongoDB Atlas instance, there's only one piece of the puzzle missing: a way to retrieve the latest song from the database. Usually, this would require a separate application that we would have to develop, manage in the cloud, or provide a bare metal to run on, but here's the kicker: MongoDB has a way to do this easily with MongoDB Application Services. Application Services allows writing custom HTTP endpoints to retrieve or manipulate database data.

To create an endpoint like that, log in to your [MongoDB Atlas Account](https://account.mongodb.com/account/login). After creating a project, go to App Services at the top and then Create a New App. Name your app, click on Create App Service, and then on the left, you’ll see the HTTP Endpoints entry. After clicking Add Endpoint, select all the relevant settings. 

![Creating new Atlas Application HTTP Endpoint](https://mongodb-devhub-cms.s3.us-west-1.amazonaws.com/creating_new_atlas_application_1fa3569e35.png)

The fetchsong function is a small JavaScript function that returns the latest song if the latest song had been played in the last 15 minutes and connected it to an HTTPS endpoint. Here it is in full glory: 

```Javascript
exports = async function (request, response) {
    const filter = {date: {$gt: new Date(new Date().getTime() - 15 * 60000)}};
    const projection = {artist: 1, title: 1, _id: 0};

    const songsCollection = context.services.get("mongodb-atlas")
        .db("scaleup")
        .collection("songs");
    const docs = await songsCollection
        .find(filter, projection)
        .sort({date: -1})
        .limit(1).toArray();

    const [latestSong] = docs;
    response.setBody(latestSong);
};
```

And voilà! After embedding a JavaScript snippet on our website to read song data here’s the final outcome:

![Currently played song on Spotify](https://mongodb-devhub-cms.s3.us-west-1.amazonaws.com/currently_listening_on_spotify_958c61934e.png)

To see the results for yourself, visit [https://scaleup.com.pl/en/#music](https://scaleup.com.pl/en/#music). If you don't see anything, don’t worry—we work in the Central European Time Zone, so the office might be currently empty. :) Also, if you need to hire IT specialists here in Poland, don't hesitate to drop us a message. ;) 

Huge thanks to John Page for being an inspiration to play with MongoDB's products and to write this article. The source code for the whole project is [available on GitHub](https://github.com/janpetryk/scale-up-music-listener). :) 

Learn how Scale Up publishes the title of the song currently playing in their office regardless of the musical source using an old cellphone and MongoDB Atlas Application Services.

Listen Along at Scale Up with Atlas Application Services

Pavel Duchovny

Modern platforms have a wide variety of data sources. As businesses grow, they have to constantly evolve their data management and have sophisticated, scalable, and convenient tools to analyse data from all sources to produce business insights.

MongoDB has developed a rich and powerful [query language](https://docs.mongodb.com/manual/tutorial/query-documents/), including a very robust [aggregation framework](https://docs.mongodb.com/manual/aggregation/). 

These were mainly done to optimize the way developers work with data and provide great tools to manipulate and query MongoDB documents.

Having said that, many developers, analysts, and tools still prefer the legacy SQL language to interact with the data sources. SQL has a strong foundation around joining data as this was a core concept of the legacy relational databases normalization model. 

This makes SQL have a convenient syntax when it comes to describing joins. 

Providing MongoDB users the ability to leverage SQL to analyse multi-source documents while having a flexible schema and data store is a compelling solution for businesses.

## Data Sources and the Challenge

Consider a requirement to create a single view to analyze data from operative different systems. For example:

- Customer data is managed in the user administration systems (REST API).
- Financial data is managed in a financial cluster (Atlas cluster).
- End-to-end transactions are stored in files on cold storage gathered from various external providers (S3 store).

How can we combine and best join this data? 

[MongoDB Atlas Query Federation](https://www.mongodb.com/docs/atlas/data-federation/) connects multiple data sources using the different [data store types](https://www.mongodb.com/docs/atlas/data-federation/overview/#mongodb-expression-exp.Data-Store). Once the data sources are mapped, we can create collections consuming this data. Those collections can have [SQL schema](https://docs.mongodb.com/datalake/reference/cli/sql/sqlgenerateschema/) generated, allowing us to perform sophisticated joins and do JDBC queries from various BI tools.

In this article, we will showcase the extreme power hidden in Atlas [SQL Query](https://www.mongodb.com/docs/atlas/data-federation/query/query-with-sql/).

## Setting Up My Federated Database Instace
In the following view, I have created three main data stores: 
- S3 Transaction Store (S3 sample data).
- Accounts from my Atlas clusters (Sample data sample_analytics.accounts).
- Customer data from a secure https source.

![Query Federation Sources](https://mongodb-devhub-cms.s3.us-west-1.amazonaws.com/Screenshot_2022_06_20_at_12_33_52_ec0802abed.png)

I mapped the stores into three collections under `FinTech` database:

- `Transactions`
- `Accounts`
- `CustomerDL`

Now, I can see them through a  Query Federation connection as MongoDB collections.

Let's grab our Query Federation instance connection string from the Atlas UI.

![Connection](https://mongodb-devhub-cms.s3.us-west-1.amazonaws.com/Screenshot_2022_06_20_at_12_37_55_be8464c0d1.png)

This connection string can be used with our BI tools or client applications to run SQL queries.

## Connecting and Using $sql and db.sql

Once we connect to the Query Federation instancee via a mongosh shell, we can generate a SQL schema for our collections. This is optional for the JDBC or $sql operators to recognise collections as SQL “tables”  as this step is done automatically for newly created collections, however, its always good to be familiar with the available commands.

#### Generate SQL schema for each collection:
```js
use admin;
db.runCommand({sqlGenerateSchema: 1, sampleNamespaces: ["FinTech.customersDL"], sampleSize: 1000, setSchemas: true})
{
  ok: 1,
  schemas: [ { databaseName: 'FinTech', namespaces: [Array] } ]
}
db.runCommand({sqlGenerateSchema: 1, sampleNamespaces: ["FinTech.accounts"], sampleSize: 1000, setSchemas: true})
{
  ok: 1,
  schemas: [ { databaseName: 'FinTech', namespaces: [Array] } ]
}
db.runCommand({sqlGenerateSchema: 1, sampleNamespaces: ["FinTech.transactions"], sampleSize: 1000, setSchemas: true})
{
  ok: 1,
  schemas: [ { databaseName: 'FinTech', namespaces: [Array] } ]
}
```
#### Running SQL queries and joins using $sql stage:
```js
use FinTech;
db.aggregate([{
  $sql: {
    statement: "SELECT a.* , t.transaction_count FROM accounts a, transactions t where a.account_id = t.account_id SORT BY t.transaction_count DESC limit 2",
    format: "jdbc",
    formatVersion: 2,
    dialect: "mysql",
  }
}])

// Equivalent command
db.sql("SELECT a.* , t.transaction_count FROM accounts a, transactions t where a.account_id = t.account_id SORT BY t.transaction_count DESC limit 2");
```

The above query will prompt account information and the transaction counts of each account.

## Connecting Via JDBC

Let’s connect a powerful BI tool like Tableau with the [JDBC driver](https://www.mongodb.com/docs/atlas/data-federation/query/sql/drivers/jdbc/connect/).

[Download JDBC Driver](https://search.maven.org/artifact/org.mongodb/mongodb-jdbc).

![Latest Driver](https://mongodb-devhub-cms.s3.us-west-1.amazonaws.com/Screenshot_2022_06_20_at_12_44_11_e2df7beb3c.png)

#### Connect to Tableau
You have 2 main options to connect, via "MongoDB Atlas" connector or via a JDBC general connector. Please follow the relevant instructions and prerequisites on this [documentation](https://www.mongodb.com/docs/atlas/data-federation/query/sql/tableau/connect/) page.

##### Connector "MongoDB Atlas by MongoDB"
Search and click the  “MongoDB Atlas by MongoDB” connector and provide the information pointing to our Query Federation URI. See the following example:

![Tablue Connector](https://mongodb-devhub-cms.s3.us-west-1.amazonaws.com/Screenshot_2022_06_20_at_12_50_53_ace30bbb42.png)

##### "JDBC" Connector

Setting `connection.properties` file.
```
user=root
password=*******
authSource=admin
database=FinTech
ssl=true
compressors=zlib
```

Click the “Other Databases (JDBC)” connector, copy JDBC connection format, and load the `connection.properties` file.

![Tableau Connector Selection](https://mongodb-devhub-cms.s3.us-west-1.amazonaws.com/tableau_select_other_db_1c75d7023c.png)

Once the data is read successfully, the collections will appear on the right side.

#### Setting and Joining Data

![Setting Tables](https://mongodb-devhub-cms.s3.us-west-1.amazonaws.com/Screen_Shot_2021_10_17_at_11_19_53_8913b663c6.png)

We can drag and drop collections from different sources and link them together.

![Joining Tables with Drag & Drop](https://mongodb-devhub-cms.s3.us-west-1.amazonaws.com/Screen_Shot_2021_10_17_at_15_14_36_0e2fdcae97.png)

In my case, I connected `Transactions` => `Accounts` based on the `Account Id` field, and accounts and users based on the `Account Id` to `Accounts` field.

![Unified View of Accounts, Transactions and Users data](https://mongodb-devhub-cms.s3.us-west-1.amazonaws.com/Screen_Shot_2021_10_17_at_15_06_50_9e906438d5.png)

In this view, we will see a unified table for all accounts with usernames and their transactions start quarter. 

## Summary

MongoDB has all the tools to read, transform, and analyse your documents for almost any use-case.  

Whether your data is in an Atlas operational cluster, in a service, or on cold storage like S3, Atlas Query Federation will provide you with the ability to join the data in real time. With the option to use powerful join SQL syntax and SQL-based BI tools like Tableau, you can get value out of the data in no time.

Try Atlas Query Federation with your BI tools and SQL today.

Learn how new SQL-based queries can power your Query Federation insights in minutes. Integrate this capability with powerful BI tools like Tableau to get immediate value out of your data. 

Atlas Query Federation SQL to Form Powerful Data Interactions

Rachelle Palmer

##  Introduction
So you've decided to write a Rust application with MongoDB, and you're wondering which of the top web development frameworks to use? Below, we give some suggestions and resources for how to:

1. Use MongoDB with Actix and Rust
2. Use MongoDB with Rocket.rs and Rust


The TLDR is that any of the popular Rust frameworks can be used with MongoDB, and we have code examples, tutorials, and other resources to guide you.

### Building MongoDB Rust Apps with Actix

[Actix](https://github.com/actix/actix-web) is a powerful and performant web framework for building Rust applications, with a long list of supported features. 

You can find a working example of using MongoDB with Actix in the `databases` directory under actix's github [here](https://github.com/actix/examples/tree/master/databases/mongodb), but otherwise, if you're looking to build a REST API with Rust and MongoDB, using Actix along the way, [this tutorial](https://dev.to/hackmamba/build-a-rest-api-with-rust-and-mongodb-actix-web-version-ei1) is one of the better ones we've seen.



### Building MongoDB Rust Apps with Rocket.rs

Prefer [Rocket](https://rocket.rs/)? Rocket is fast, secure, and type safe framework that is low on boilerplate. It's easy to use MongoDB with Rocket to build Rust applications. There's a tutorial on medium we particularly like - that's [here](https://medium.com/geekculture/build-a-rest-api-with-rust-and-mongodb-rocket-version-7ea90ebd9fe7) - on building a REST API with Rust and MongoDB and Rocket. 

If all you want is to see a code example on github, we recommend [this one.](https://github.com/TaeyoonKwon/rust-rocket-sample).







Articles

Featured Articles

Listen Along at Scale Up with Atlas Application Services

Atlas Query Federation SQL to Form Powerful Data Interactions

Using Rust Web Development Frameworks with MongoDB

All Articles