To recover deleted data from an Oracle database after using the `delete from table` command to remove the data, you have to take note of the timestamp (date and time) when the data was deleted.

The timestamp is used as a flashpoint to recover back the deleted data.

Modify the below script to see/retrieve the deleted data.

```sql
select * from MY_TABLE 
as of timestamp to_timestamp('04-MAY-2017 13:30:00', 'DD-MON-YYYY HH24:MI:SS') 
where 'some condition';
```

In the above script, the time specified in the `to_timestamp` would return the dataset is as at the specified time (before the data was deleted). You can also use the `where` clause to filter the result set.

The timestamp above is in 24HRS format, for a 12HRS format use the below timestamp format.

```sql
select * from MY_TABLE 
as of timestamp to_timestamp('04-MAY-2017 12:30:00', 'DD-MON-YYYY HH:MI:SS') 
where 'some condition';
```

Happy coding!!!

How to recover deleted Data from an Oracle database Table

Mic test one, two, three.

Hello world from the cloud.

Test from cloud


Open [http://localhost:3000](http://localhost:3000) with your browser to see the result.

## Intro

```python
def function(foo):
    print(foo)
```

- [ ] Run `> npm-install` to install the project dependencies
- [x] Install gulp.js via the Mac terminal or Gitbash on a PC `> npm install -g gulp`
- [ ] Run the Gulp command `> gulp`

| Dimensions    | Megapixels |
| ------------- | ---------- |
| 1,920 x 1,080 | 2.1MP      |
| 3,264 x 2,448 | 8MP        |
| 4,288 x 3,216 | 14MP       |

- `console.log`
- `console.table`
- `console.warn`

![Egusi Soup](https://www.nairaland.com/attachments/14372142_inshot20211012125616600_jpeg8347a0d760394d6f70f2528d70a436c8)

I may not talk alot here, because the topic is pretty straight forward and speaks for its self.

```javascript
const one = 12;
console.log("hello", one);
```

prints
`hello 12`

Peace out!!!

### Get the List of Department without Manager

To get all the department that has no manager assign to them we have to make use of `joins` to join the related tables we need to make use.

We would ben using three tables `departments`, `locations` and `countries`.
Run the code below to see it in action.

```sql
select l.city || c.country_name, d.department_name
from departments d, locations l, countries c
where d.location_id = l.location_id
and d.manager_id is null;
```

```sql
SELECT MAX(ROW_KEY) FROM CS_00_CUS_CTC_X;
--
ALTER TABLE CS_00_CUS ENABLE ALL TRIGGERS;
--
SELECT * FROM CS_00_DCS
WHERE DOC_K NOT IN
(SELECT ROW_KEY FROM CS_00_DCR WHERE CUS_TP_DM = 'J')
AND CUS_K = '1014625';
```

That would be all for today.


Intro to Next

Nigeria’s four major aviation unions on Wednesday vowed to ground activities in the sector from Tuesday, February 8, 2022, over the failure of the Federal Government to release the negotiated conditions of service of aviation agencies since 2013 and the non-implementation of the National Minimum Wage/consequential adjustment since 2019.

In a notice of industrial action jointly signed by officials of the unions and issued to aviation workers, the associations said flights and related activities would be brought suspended.

The unions include the National Union of Air Transport Employees, Air Transport Services Senior Staff Association of Nigeria, Association of Nigeria Aviation Professionals, and the Amalgamated Union of Public Corporations, Civil Service Technical and Recreational Services Employees.

“By this notice, all airlines, ground handling companies, aviation security/logistics, in-flight catering, and other aviation-related businesses, as well as the traveling and general public, are hereby notified that aviation services will be unavailable as from the given time until the issues are fully resolved,” they declared.

The aviation workers’ union recalled that they had earlier sent ultimatums to the Federal Ministry of Aviation and its six agencies about workers’ concerns but nothing was done.

The notice read in part, “As you are all aware, our unions variously issued ultimatums to the Federal Ministry of Aviation and the six aviation agencies over the vexed issues of failure to release negotiated conditions of service of the agencies since 2013 and the non-implementation of minimum wage/consequential adjustment since 2019.

“All the ultimatums expired January 31, 2019, without the demands being met in any form. The meeting called by the Federal Ministry of Aviation on the same January 31, 2013 did not resolve the issues as there was no clear assurance from the ministry/managements’ delegation towards meeting our genuine demands.

“In the circumstance, our unions are left with no choice but to take the next obvious step. In this regard, all aviation workers are hereby directed to commence the total withdrawal of services from midnight of Tuesday, February 8, 2022, unless, and until, otherwise directed in this same manner.”

The unions advised the managements of FAAN, NCAA, NAMA, NiMet, AIB, and NCAT, in conjunction with the Federal Ministry of Aviation to utilise the one-week window so provided to avert the looming crisis by prevailing on the relevant government agencies to act jointly to ensure that workers’ twin demands were met.

They said, “All conditions of service of the NCAA, NAMA, FAAN, NiMet and any other aviation agency pending before the Ministry of Aviation; National Salaries, Incomes and Wages Commission; the Office of the Head of Civil Service of the Federation, or any other organ of government or management of the agencies must be released wholly for implementation with the effective date of the signing of the agreement between our unions and the respective agencies.

“And the new minimum wage/consequential adjustment must be immediately implemented with effect from the law’s effective date of April 2019.”

Aviation Unions Vow To Ground Flights February 8 Over Minimum Wage Others

# Introduction

Database Schema Migration is the process of updating a Collection Schema and/or adapting the existing data for new requirements.

The objective of this post is to learn about the different ways a migration tool can help us to write scripts that modify your database by adding new documents, modifying existing ones, or changing the collection schema.

[![1](https://softwareontheroad.com/static/f0c686a5fb90fb522c223340e584880b/4a896/1.jpg)](https://softwareontheroad.com/static/f0c686a5fb90fb522c223340e584880b/8299d/1.jpg)

# This is why you need a migration tool for MongoDB

We know that mongo is a non-relational database schema-free database, but in most of the projects, we tend to use it with Mongoose, a popular ODM for MongoDB which allows us to add Schema to our collections.

And as software evolves, we may need to fix mistakes on the data schema or adapt existing data as requirements change.

Now the problem is that we can’t rely on running manual update commands on the MongoDB shell since that is prone to errors or some times we need a special tool like `lodash` or `moment` to perform some modifications to dates or arrays.

Also, when we need to perform several updates that have a special order, it is pretty common to mix those up and broke the data.

The solution is to use a specialized tool, such as the npm package `migrate-mongo`

This way we will have an incremental, reversible, and version-controlled way to handle database schema migrations.

# Example of use cases

Let’s explore some use cases for MongoDB migrations:

- Adding new relations to existing collections. For example, in an e-commerce app, you added a new entity like ‘brand’ and now you need to update certain ‘products’ to have a relation to that brand.
- Renaming fields. Useful when you need to change a field that, for example, was named `created` and now will be `signupDate`.
- Adding fields to existing documents. Sometimes (or a lot of times) as your app grows you, find that the database schemas you designed the first time need to be expanded. For example, adding a field `quantity` to a `products` table in order to model the current stock.
- Separating fields into new document properties. A classic example is having a field `name` that now is divided into `firstName` and `lastName`

[![3](https://softwareontheroad.com/static/d3b2ad135e54ee65385065466751ee77/8ba71/3.jpg)](https://softwareontheroad.com/static/d3b2ad135e54ee65385065466751ee77/8ba71/3.jpg)

# Using the migration tool

While there is a variety of tools to perform migrations, my favorite is `migrate-mongo` because it’s well documented and actively developed.

To install it:

```text
npm install -g migrate-mongo
```

I installed it globally, but you can also install it locally on your project and then invoke it from an npm command [(see about it in next section)](https://softwareontheroad.com/database-migration-node-mongo/#migration-tool-running) Or you can even use `npx` to avoid installing it on your server.

## Let’s now see how to use it.

The first step is to init the migrations tool

```text
migrate-mongo init
```

This will create a `migrate-mongo-config.js` configuration file and a `migrations` folder at the root of our project.

```text
|_ src/
|_ migrations/
   |- 20200606204524-migration-1.js
   |- 20200608124524-migration-2.js
   |- 20200808114324-migration-3.js
|- migrate-mongo.js
|- package.json
|- package-lock.json
```

## Migrate-mongo configuration file

In the configuration file, we can define our database URL, I have it stored on a config file in another folder, where it loads it depending on the environment (such as local, staging, production) Also, we can change the MongoDB connection parameters, and finally, in which collection, the current database version will be saved.

```js
// In this file you can configure migrate-mongo
const env = require('./server/config')
const config = {
  mongodb: {
    // TODO Change (or review) the url to your MongoDB:
    url: env.mongo.url || "mongodb://localhost:27017",

    // TODO Change this to your database name:
    databaseName: env.mongo.dbname || "YOURDATABASENAME",

    options: {
      useNewUrlParser: true, // removes a deprecation warning when connecting
      useUnifiedTopology: true, // removes a deprecating warning when connecting
      //   connectTimeoutMS: 3600000, // increase connection timeout up to 1 hour
      //   socketTimeoutMS: 3600000, // increase socket timeout up to 1 hour
    }
  },

  // The migrations dir can be a relative or absolute path. Only edit this when really necessary.
  migrationsDir: "migrations",

  // The MongoDB collection where the applied changes are stored. Only edit this when really necessary.
  changelogCollectionName: "changelog"
};
module.exports = config;
```

## Migrations folder

Inside the migrations folder, our scripts will be sorted by date.

The date is appended to the beginning of the file name.

```text
|_ migrations/
   |- 20200606204524-change-name-to-full-name.js
   |- 20200608124524-add-user-default-picture.js
   |- 20200808114324-remove-old-property.js
   |- 20210108114324-change-password-hashing.js
```

That way the tool ensures us the scripts will be run in order.

## Adding a migration

To add a new migration script, use the CLI command

```text
migrate-mongo create name-of-my-script
```

A new file will be created with a corresponding timestamp.

```text
|_ migrations/
   |- 20210108114324-name-of-my-script.js
```

## The up function

The script file expects us to export an object with a UP function and a DOWN function.

When the scripts are applied, the up function is responsible for changing the database schema.

```js
module.exports = {
    function up(db) {
        return db.collection('products').updateMany({}, { $set: { quantity: 10 } })
    }
    
    function down(db) {
        return db.collection('products').updateMany({}, { $unset: { quantity: null } })
    }
}
```

[![2](https://softwareontheroad.com/static/853c0599b9c3eeefb8dce59877f74e4f/4a896/2.jpg)](https://softwareontheroad.com/static/853c0599b9c3eeefb8dce59877f74e4f/8299d/2.jpg)

But don’t limit yourself by this simple file, it is a regular js file where you can import/require any library that you need (lodash.js / moment.js / etc)

Here is an example that sets an additional field that needs to be calculated using moment.js

```js
const moment = require('moment');

module.exports = {
    async   function up(db) {
    const products = await db.collection.get('products').find({}).toArray();
        const operations = products.map((product) => {
            return db.collection('products').updateOne({ _id: product._id }, {
                    $set: {
                        weekDay: moment(product.date).day()
                    }
            })          
        })
        return Promise.all(operations);
    }
    
    function down(db) {
        return db.collection('products')
                    .updateMany({}, { $unset: { weekDay: null } });
    }
}
```

## The down function

This is how you go back to the previous database state.

```js
module.exports = {
    function up(db) {
        return db.collection('users').updateMany({}, { $rename: { name: "fullName" } })
    }
    
    function down(db) {
        return db.collection('users').updateMany({}, { $rename: { fullName: "name" } })
    }
}
```

It is not always possible to go back to the previous state

```js
module.exports = {
    function up(db) {
        return db.collection('users').deleteMany({ name: /Sam/ })
    }
    
    function down(db) {
        // But we can't recover deleted documents...
        return Promise.resolve('ok')
    }
}
```

## The database changelog

In order to know the current database version and which migration should apply next, there is a special collection that stores the database changelog with information such as migrations applied, and when where they applied.

[![2](https://softwareontheroad.com/static/a39b8e76e3af8af3167fb9ce9a889bcc/15740/changelog.jpg)](https://softwareontheroad.com/static/a39b8e76e3af8af3167fb9ce9a889bcc/15740/changelog.jpg)

## Running migrations

To run your migrations, simply run the command

```bash
migrate-mongo up
```

Also, you can add it to your package.json as an npm script

```json
{
    "scripts": {
        "migrate:up": "migrate-mongo up",
        "migrate:down": "migrate-mongo down"
    }
}
```

This `up` command will run every migration that wasn’t already applied to your database. It uses the changelog collection to know the current database state and version.

To rollback a migration use the `down` command:

```bash
migrate-mongo down
```

This will only roll back one single migration, the latest applied.

# Automated migrations

The way to run this on your production/staging server is by using a simple script after the `npm install` and before the start of the server

### Heroku

According to Heroku’s documentation for node.js you may specify a post-build script that is executed every time a new update is sent.

Inside your package.json

```json
"scripts": {
  "heroku-postbuild": "migrate-mongo up",
}
```

You can read more about Heroku build steps here:

https://devcenter.heroku.com/articles/nodejs-support#heroku-specific-build-steps

### Digital Ocean

On D.O things vary depending on your setup, but what we aim is to execute the migrate tool after the node.js dependencies installation process, but before starting up the node.js application.

For example, here is a bash script that can be executed by login-in through ssh into the digital ocean droplet.

```bash
# Go to the app folder
cd ~/apps/my-app
# Install all dependencies
npm install
# Run migrations
migrate-mongo up
# Restart the node.js app
pm2 restart my-app
```

# Conclusion

By using a database schema migration tool you will archive incremental, reversible, and version-controlled way to apply schema and data changes.

With the tool `migrate-mongo` we can have all of that and if we combine it with the power of continuous delivery applied to Heroku or Digital Ocean we are ready to scale!

All you need to know about MongoDB schema migrations in node.js

To return a list of all records where the decimal place is greater than 2, use the code below.
You can replace the 2 to any number of the desired decimal place.

```sql
SELECT * FROM TABLE_A
WHERE COL_A != ROUND (COL_A, 2);
```

How to recover deleted Data from an Oracle database Table

Read next

Hello world one two three for

Hello world

Hello world

Hello world

LOCATION

EDUCATION

WORK

JOINED

More from Austin Ofor