TABLE_EXISTS_ACTION Option In IMPDP

Useful Oracle 12c Pluggable database commands

How to work with checkboxes in React

How To Change Git Remote Origin

How to copy all the file names in a folder in Windows

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

Lucky football

Hesjsk

Query to get record where a column is greater than 2 decimal place

Testing

Test from cloud

Intro to Next

For Arsenal fans, hope has become a familiar yet fragile companion. Each season seems to begin with renewed belief, a sense that this could finally be the year the long wait for silverware comes to an end. But once again, that hope has been shaken—this time by a sobering defeat to Manchester City.

![Arsenal vs Mancity](https://external-content.duckduckgo.com/iu/?u=https%3A%2F%2Fcloudfront-us-east-2.images.arcpublishing.com%2Freuters%2F2C7H2JAFYBJHRPZKOJ42PLESNI.jpg&f=1&nofb=1&ipt=bf782bf2b7f22c947426d5d67b31c36e242a6d7b90fdc980fc8eac8ef44f1345)

The loss wasn’t just another result on the fixture list. It carried weight, context, and a lingering sense of déjà vu. Arsenal didn’t just lose a match—they lost another opportunity to rewrite a narrative that has followed them for far too long.

## A Club Still Searching for Its Moment

It has been years since Arsenal last lifted a major trophy, and that absence is beginning to define the modern identity of the club. Once known for elegance, dominance, and a winning mentality, Arsenal now finds itself stuck in a cycle of “almost.”

Against Manchester City, the gap was evident. City didn’t just play better—they played like a team accustomed to winning when it matters most. Their composure, tactical discipline, and clinical finishing stood in stark contrast to an Arsenal side that, despite moments of promise, lacked the cutting edge required on big occasions.

## Missed Chances, Familiar Story

Arsenal’s performance wasn’t devoid of positives. There were flashes of creativity, spells of control, and periods where they looked capable of competing toe-to-toe with one of Europe’s elite. But as has so often been the case, they failed to capitalize when it mattered most.

Missed chances proved costly. Defensive lapses were punished ruthlessly. And as the match slipped away, so too did another shot at ending the drought.

This is what makes the defeat particularly painful. It’s not just that Arsenal lost—it’s how predictable the outcome felt once the momentum shifted. The inability to seize key moments continues to haunt them.

## The Psychological Barrier

Perhaps the biggest challenge Arsenal faces now isn’t tactical—it’s mental.

When a team goes this long without lifting silverware, doubt inevitably creeps in. Big games begin to feel heavier. Pressure mounts. And every setback reinforces a narrative that becomes harder to escape.

Manchester City, by contrast, thrives under that pressure. They expect to win—and more often than not, they do.

For Arsenal, bridging that psychological gap may be just as important as improving on the pitch.

## Where Do They Go From Here?

Despite the disappointment, this isn’t a team without potential. There is talent in the squad, a clear footballing philosophy, and a fanbase that remains passionately supportive.

But potential alone is no longer enough.

Arsenal must find a way to turn promise into results. They must learn how to win ugly, how to manage games, and how to deliver when the stakes are highest. Because until they do, matches like this will continue to define their season—and their reputation.

## A Familiar Pain, An Uncertain Future

For now, the wait goes on.

Another season, another missed opportunity, another reminder of how far Arsenal still has to go. The defeat to Manchester City is not just a setback—it’s a symbol of a deeper issue that the club must confront.

Until Arsenal can overcome both their opponents and their own history, the question will remain:

**When will the waiting finally end?**

Arsenal's Trophy Drought Deepens After Painful Defeat to Manchester City

Arsenal Trophy Drought Deepens After Painful Defeat to Manchester City

Test

Arsenal’s Trophy Drought Deepens After Painful Defeat

Arsenal’s Trophy Drought Deepens After Painful Defeat to Manchester City

# Arsenal’s Trophy Drought Deepens After Painful Defeat to Manchester City

![Arsenal vs Manchester City match action](https://external-content.duckduckgo.com/iu/?u=https%3A%2F%2Fmedia.assettype.com%2Foutlookindia%2F2025-09-22%2F5cbjxb1m%2FBritain-soccer-Premier-League-2025-26-Arsenal-Vs-Manchester-City-match-pics4.jpg%3Fw%3D801%26auto%3Dformat%252Ccompress%26fit%3Dmax%26format%3Dwebp%26dpr%3D1.0&f=1&nofb=1&ipt=bed984c3bfe68212e3ec450fdda9aafcc9ef1dca809d3bca35f7fb3419ae2fa4)

For Arsenal fans, hope has become a familiar yet fragile companion. Each season seems to begin with renewed belief, a sense that this could finally be the year the long wait for silverware comes to an end. But once again, that hope has been shaken—this time by a sobering defeat to Manchester City.

The loss wasn’t just another result on the fixture list. It carried weight, context, and a lingering sense of déjà vu. Arsenal didn’t just lose a match—they lost another opportunity to rewrite a narrative that has followed them for far too long.

## A Club Still Searching for Its Moment

It has been years since Arsenal last lifted a major trophy, and that absence is beginning to define the modern identity of the club. Once known for elegance, dominance, and a winning mentality, Arsenal now finds itself stuck in a cycle of “almost.”

Against Manchester City, the gap was evident. City didn’t just play better—they played like a team accustomed to winning when it matters most. Their composure, tactical discipline, and clinical finishing stood in stark contrast to an Arsenal side that, despite moments of promise, lacked the cutting edge required on big occasions.

## Missed Chances, Familiar Story

Arsenal’s performance wasn’t devoid of positives. There were flashes of creativity, spells of control, and periods where they looked capable of competing toe-to-toe with one of Europe’s elite. But as has so often been the case, they failed to capitalize when it mattered most.

Missed chances proved costly. Defensive lapses were punished ruthlessly. And as the match slipped away, so too did another shot at ending the drought.

This is what makes the defeat particularly painful. It’s not just that Arsenal lost—it’s how predictable the outcome felt once the momentum shifted. The inability to seize key moments continues to haunt them.

## The Psychological Barrier

Perhaps the biggest challenge Arsenal faces now isn’t tactical—it’s mental.

When a team goes this long without lifting silverware, doubt inevitably creeps in. Big games begin to feel heavier. Pressure mounts. And every setback reinforces a narrative that becomes harder to escape.

Manchester City, by contrast, thrives under that pressure. They expect to win—and more often than not, they do.

For Arsenal, bridging that psychological gap may be just as important as improving on the pitch.

## Where Do They Go From Here?

Despite the disappointment, this isn’t a team without potential. There is talent in the squad, a clear footballing philosophy, and a fanbase that remains passionately supportive.

But potential alone is no longer enough.

Arsenal must find a way to turn promise into results. They must learn how to win ugly, how to manage games, and how to deliver when the stakes are highest. Because until they do, matches like this will continue to define their season—and their reputation.

## A Familiar Pain, An Uncertain Future

For now, the wait goes on.

Another season, another missed opportunity, another reminder of how far Arsenal still has to go. The defeat to Manchester City is not just a setback—it’s a symbol of a deeper issue that the club must confront.

Until Arsenal can overcome both their opponents and their own history, the question will remain:

**When will the waiting finally end?**

TABLE_EXISTS_ACTION parameter is required while importing table, which is already present in the database. We can put required value, according to our requirement.

 

> **TABLE_EXISTS_ACTION**
> **Action to take if** imported **object already exists.**
> **Valid keywords are: APPEND, REPLACE, [SKIP] and TRUNCATE.**
>
>  

**TABLE_EXISTS_ACTION=APPEND:**

With this option, while importing the table, if the table exists in the database, then it will append the data on top the existing data in the table.

```
select count(*) from "DBATEST"."EMP_TAB";

COUNT(*)
----------
175340


impdp dumpfile=emp_tab.dmp logfile=emp_tab.log directory=VEN table_exists_action=APPEND


Starting "SYS"."SYS_IMPORT_FULL_01": /******** AS SYSDBA dumpfile=emp_tab.dmp logfile=emp_tab.log directory=VEN table_exists_action=APPEND
Processing object type TABLE_EXPORT/TABLE/TABLE
Table "DBATEST"."EMP_TAB" exists. Data will be appended to existing table but all dependent metadata will be skipped due to table_exists_action of append
Processing object type TABLE_EXPORT/TABLE/TABLE_DATA
. . imported "DBATEST"."EMP_TAB" 19.16 MB 175340 rows
Job "SYS"."SYS_IMPORT_FULL_01" successfully completed at Tue Jan 24 08:57:09 2017 elapsed 0 00:01:18


SQL[SYS@]SQL>>]select count(*) from "DBATEST"."EMP_TAB";

COUNT(*)
----------
350680
```



**TABLE_EXISTS_ACTION=TRUNCATE:**

While importing the table, if the table exists in database, it will truncate the table and load the data.

```
impdp dumpfile=emp_tab.dmp logfile=emp_tab.log directory=VEN table_exists_action=TRUNCATE

Starting "SYS"."SYS_IMPORT_FULL_01": /******** AS SYSDBA dumpfile=emp_tab.dmp logfile=emp_tab.log directory=VEN table_exists_action=TRUNCATE
Processing object type TABLE_EXPORT/TABLE/TABLE
Table "DBATEST"."EMP_TAB" exists and has been truncated. Data will be loaded but all dependent metadata will be skipped due to table_exists_action of truncate
Processing object type TABLE_EXPORT/TABLE/TABLE_DATA
. . imported "DBATEST"."EMP_TAB" 19.16 MB 175340 rows
Job "SYS"."SYS_IMPORT_FULL_01" successfully completed at Tue Jan 24 09:02:23 2017 elapsed 0 00:01:11
```

**TABLE_EXISTS_ACTION=REPLACE:**

While importing , if the table exists in database, then it will drop it and recreate it from the dump

```
impdp dumpfile=emp_tab.dmp logfile=emp_tab.log directory=VEN table_exists_action=REPLACE

Starting "SYS"."SYS_IMPORT_FULL_01": /******** AS SYSDBA dumpfile=emp_tab.dmp logfile=emp_tab.log directory=VEN table_exists_action=REPLACE
Processing object type TABLE_EXPORT/TABLE/TABLE
Processing object type TABLE_EXPORT/TABLE/TABLE_DATA
. . imported "DBATEST"."EMP_TAB" 19.16 MB 175340 rows
Job "SYS"."SYS_IMPORT_FULL_01" successfully completed at Tue Jan 24 09:20:30 2017 elapsed 0 00:01:37
```



**TABLE_EXISTS_ACTION=SKIP:**

This is the defult option with impdp. I.e if the the table exists, it will skip that table.

```
Starting "SYS"."SYS_IMPORT_FULL_01": /******** AS SYSDBA dumpfile=emp_tab.dmp logfile=emp_tab.log directory=VEN
Processing object type TABLE_EXPORT/TABLE/TABLE
ORA-39151: Table "DBATEST"."EMP_TAB" exists. All dependent metadata and data will be skipped due to table_exists_action of skip
Processing object type TABLE_EXPORT/TABLE/TABLE_DATA
Job "SYS"."SYS_IMPORT_FULL_01" completed with 1 error(s) at Tue Jan 24 09:31:51 2017 elapsed 0 00:01:01
```

The planned protest is going to be successful.

## Reason One

The nation is hungry, prices of foodstuffs are skyrocketing and the inflation is on the rise on a daily basis.

End Hunger Protest

The Levenshtein distance is a string metric for measuring the difference between two sequences. It is the minimum number of single-character edits required to change one word into the other.

### For example −
Consider, we have these two strings −

```js
const str1 = 'hitting';
const str2 = 'kitten';
```

The Levenshtein distance between these two strings is 3 because we are required to make these three edits −
- kitten → hitten (substitution of "h" for "k")
- hitten → hittin (substitution of "i" for "e")
- hittin → hitting (insertion of "g" at the end)

We are required to write a JavaScript function that takes in two strings and calculates the Levenshtein distance between them.

### Example
Following is the code −

```js
const str1 = 'hitting';
const str2 = 'kitten';
const levenshteinDistance = (str1 = '', str2 = '') => {
   const track = Array(str2.length + 1).fill(null).map(() =>
   Array(str1.length + 1).fill(null));
   for (let i = 0; i <= str1.length; i += 1) {
      track[0][i] = i;
   }
   for (let j = 0; j <= str2.length; j += 1) {
      track[j][0] = j;
   }
   for (let j = 1; j <= str2.length; j += 1) {
      for (let i = 1; i <= str1.length; i += 1) {
         const indicator = str1[i - 1] === str2[j - 1] ? 0 : 1;
         track[j][i] = Math.min(
            track[j][i - 1] + 1, // deletion
            track[j - 1][i] + 1, // insertion
            track[j - 1][i - 1] + indicator, // substitution
         );
      }
   }
   return track[str2.length][str1.length];
};
console.log(levenshteinDistance(str1, str2));
```
### Output
Following is the output on console −

```bash
3
```

Levenshtein Distance in JavaScript

## Change Git Remote URL

**In order to change the URL of a Git remote, you have to use the “git remote set-url” command and specify the name of the remote as well as the new remote URL to be changed.**

```bash
$ git remote set-url <remote_name> <remote_url>
```

For example, let’s say that you want to **change the URL of your Git origin remote**.

In order to achieve that, you would use the “set-url” command on the “origin” remote and you would specify the new URL.

```
$ git remote set-url origin https://git-repo/new-repository.git
```

![git change remote using set url](https://devconnected.com/wp-content/uploads/2020/02/set-url.png)

Congratulations, **you successfully changed the URL of your Git remote!**

In order to verify that the changes were made, you can use the “git remote” command with the “-v” option (for verbose)

```
$ git remote -v
```

![list remote using git remote](https://devconnected.com/wp-content/uploads/2020/02/list-remotes.png)

fdgfsfasadfdgffsasassdgfvcvc c c c

# bold
_GHJS_

If you need to copy a list of files from a folder in Windows there’s a better way to do that than copying and pasting each file title. Instead, you can set up a Notepad text document with all the file titles in a folder from the Command Prompt.

Firstly, open the Command Prompt by entering cmd in the Windows Start menu search box. Alternatively, press the Windows key + R to open Run; and then enter cmd.exe. That should then open the Command Prompt window in the shot below.

[![file list](https://dt.azadicdn.com/wp-content/uploads/2014/05/file-list.jpg?7653)](https://dt.azadicdn.com/wp-content/uploads/2014/05/file-list.jpg?7653)

There you should go to the folder directory that includes the files to copy. To switch directories in the Command Prompt, enter CD followed by the folder titles. For example, to open the Windows folder you would enter CD\Windows.

[![file list2](https://dt.azadicdn.com/wp-content/uploads/2014/05/file-list2.jpg?7653)](https://dt.azadicdn.com/wp-content/uploads/2014/05/file-list2.jpg?7653)[
](https://dt.azadicdn.com/wp-content/uploads/2014/05/file-list.jpg?7653)

Once you’ve found the folder with the files in it, you should then enter the following: **dir /b >filename.txt**. Note that the filename is the title of the text document that will include the list of files. As such, you can change the filename to any other alternative document tile; but enter the rest of the command line exactly the same as below.

[![file list3](https://dt.azadicdn.com/wp-content/uploads/2014/05/file-list3.jpg?7653)](https://dt.azadicdn.com/wp-content/uploads/2014/05/file-list3.jpg?7653)

Then press Enter to set up the text document. Open Windows Explorer, and go to the folder that you copied the file titles from. You should now find that it includes a new text file with a list of all the files in the folder as below.

[![file list4](https://dt.azadicdn.com/wp-content/uploads/2014/05/file-list4-620x444.jpg?7653)](https://dt.azadicdn.com/wp-content/uploads/2014/05/file-list4.jpg?7653)

Now you can copy a variety of folder file lists much the same. They include both the file titles and formats, but little else. Those lists can be copied from Notepad into alternative software packages with which you can add line numbering, bullet points, etc if required.

You might have come across multiple instances where you will have to use checkboxes like agreeing to terms and conditions, selecting a list of preferences, etc. In this article, we will learn different scenarios of using checkboxes in React.

First, let's create a simple checkbox component as shown below:

App.js

```jsx
export const Checkbox = () => {
  return (
    <div>
      <input type="checkbox" id="checkbox" />
      <label htmlFor="checkbox">I agree to Terms of Service </label>
    </div>
  );
};
function App() {
  return (
    <div className="App">
      <Checkbox />
    </div>
  );
}
export default App;

```

Now if you test the application, you will see that you can check and uncheck the checkbox. But how do we know the current state of the checkbox?

## Storing and Reading the checkbox state

We can make use of the useState hook to store the state of the checkbox.

App.js

```jsx
import { useState } from "react";
export const Checkbox = () => {
  const [isChecked, setIsChecked] = useState(false);
  return (
    <div>
      <input type="checkbox" id="checkbox" checked={isChecked} />
      <label htmlFor="checkbox">I agree to Terms of Service </label>
      <p>The checkbox is {isChecked ? "checked" : "unchecked"}</p>
    </div>
  );
};
function App() {
  return (
    <div className="App">
      <Checkbox />
    </div>
  );
}
export default App;

```

Now if you try to check the checkbox, nothing would happen and you will see the following warning in the console:

```
You provided a checked prop to a form field without an onChange handler. This will render a read-only field. If the field should be mutable use defaultChecked. Otherwise, set either onChange or readOnly.
```

Why does this happen? As the warning suggests, we are just setting the value of the state to the checkbox and not doing anything while the checkbox state changes. So let's bind an on change handler:

App.js

```jsx
import { useState } from "react";
export const Checkbox = () => {
  const [isChecked, setIsChecked] = useState(false);
  const checkHandler = () => {
    setIsChecked(!isChecked);
  };
  return (
    <div>
      <input type="checkbox" id="checkbox" checked={isChecked} onChange={checkHandler} />
      <label htmlFor="checkbox">I agree to Terms of Service </label>
      <p>The checkbox is {isChecked ? "checked" : "unchecked"}</p>
    </div>
  );
};
function App() {
  return (
    <div className="App">
      <Checkbox />
    </div>
  );
}
export default App;

```

If you want the checkbox to be checked initially, then you can pass `true` to the useState hook while initializing it.

## Checkbox using uncontrolled input

The above example we have seen is using controlled inputs. Next, we will see how to implement the same using uncontrolled inputs. I have explained the difference between controlled and uncontrolled inputs in my [previous article](https://www.codingdeft.com/posts/react-controlled-uncontrolled/).

App.js

```jsx
import { useRef } from "react";
function App() {
  const checkboxRef = useRef(null);
  const formSubmitHandler = (e) => {
    e.preventDefault();
    alert(`The checkbox is ${checkboxRef.current.checked ? "checked" : "unchecked"}`);
  };
  return (
    <div className="App">
      <form onSubmit={formSubmitHandler}>
        <input type="checkbox" id="checkbox" defaultChecked={true} ref={checkboxRef} />
        <label htmlFor="checkbox">I agree to Terms of Service </label>
        <p>
          <button type="submit">Submit</button>
        </p>
      </form>
    </div>
  );
}
export default App;

```

Here we are providing the initial value using `defaultChecked` prop. We have created a reference to the checkbox so that we can access the value of the checkbox inside the form submit handler. Here we are not using any state to store the current state of the checkbox. It is stored in the DOM itself.

It is always recommended to use controlled components over uncontrolled components because as the name suggests, we have more control over the input.

## Reusing the checkbox component for displaying multiple checkboxes

First, let's make the checkbox component that we created earlier as a reusable component:

```jsx
import { useState } from "react";
export const Checkbox = ({ isChecked, label, checkHandler }) => {
  return (
    <div>
      <input type="checkbox" id="checkbox" checked={isChecked} onChange={checkHandler} />
      <label htmlFor="checkbox">{label}</label>
    </div>
  );
};
function App() {
  const [isChecked, setIsChecked] = useState(false);
  const checkHandler = () => {
    setIsChecked(!isChecked);
  };
  return (
    <div className="App">
      <Checkbox
        isChecked={isChecked}
        checkHandler={checkHandler}
        label="I agree to Terms of Service"
      />
      <p>The checkbox is {isChecked ? "checked" : "unchecked"}</p>
    </div>
  );
}
export default App;

```

Now let's say you have a use case where you want to display a list of pizza toppings, from which you want the users to choose. We can achieve that by the following code:

App.js

```jsx
import { useState } from "react";
const allToppings = [
  { name: "Golden Corn", checked: false },
  { name: "Paneer", checked: false },
  { name: "Tomato", checked: false },
  { name: "Mushroom", checked: false },
  { name: "Onion", checked: false },
  { name: "Black Olives", checked: false },
];

export const Checkbox = ({ isChecked, label, checkHandler, index }) => {
  return (
    <div>
      <input type="checkbox" id={`checkbox-${index}`} checked={isChecked} onChange={checkHandler} />
      <label htmlFor={`checkbox-${index}`}>{label}</label>
    </div>
  );
};

function App() {
  const [toppings, setToppings] = useState(allToppings);
  const updateCheckStatus = (index) => {
    setToppings(
      toppings.map((topping, currentIndex) =>
        currentIndex === index ? { ...topping, checked: !topping.checked } : topping
      )
    );

    // or
    // setToppings([
    //   ...toppings.slice(0, index),
    //   { ...toppings[index], checked: !toppings[index].checked },
    //   ...toppings.slice(index + 1),
    // ]);  }

    return (
      <div className="App">
        {toppings.map((topping, index) => (
          <Checkbox
            key={topping.name}
            isChecked={topping.checked}
            checkHandler={() => updateCheckStatus(index)}
            label={topping.name}
            index={index}
          />
        ))}
        <p>
          <pre>{JSON.stringify(toppings, null, 2)}</pre>
        </p>
      </div>
    );
  };
}
export default App;

```

Here we are storing the check status of the checkbox in the local state `toppings`. We have written a method `updateCheckStatus`, which will be called with the index of the changed checkbox and will update the local state. We are also displaying the current state in the JSON format so that we can verify everything is working as expected.

## Select All and Unselect All

We can implement select all and unselect all by simply updating all the checked statuses to true and false respectively.

App.js

```jsx
import { useState } from "react";

const allToppings = [
  { name: "Golden Corn", checked: false },
  { name: "Paneer", checked: false },
  { name: "Tomato", checked: false },
  { name: "Mushroom", checked: false },
  { name: "Onion", checked: false },
  { name: "Black Olives", checked: false },
];
export const Checkbox = ({ isChecked, label, checkHandler, index }) => {
  console.log({ isChecked });
  return (
    <div>
      <input type="checkbox" id={`checkbox-${index}`} checked={isChecked} onChange={checkHandler} />
      <label htmlFor={`checkbox-${index}`}>{label}</label>
    </div>
  );
};
function App() {
  const [toppings, setToppings] = useState(allToppings);
  const updateCheckStatus = (index) => {
    setToppings(
      toppings.map((topping, currentIndex) =>
        currentIndex === index ? { ...topping, checked: !topping.checked } : topping
      )
    );

    // or
    // setToppings([
    //   ...toppings.slice(0, index),
    //   { ...toppings[index], checked: !toppings[index].checked },
    //   ...toppings.slice(index + 1),
    // ]);  }

    const selectAll = () => {
      setToppings(toppings.map((topping) => ({ ...topping, checked: true })));
    };
    const unSelectAll = () => {
      setToppings(toppings.map((topping) => ({ ...topping, checked: false })));
    };
    return (
      <div className="App">
        <p>
          <button onClick={selectAll}>Select All</button>
          <button onClick={unSelectAll}>Unselect All</button>
        </p>
        {toppings.map((topping, index) => (
          <Checkbox
            key={topping.name}
            isChecked={topping.checked}
            checkHandler={() => updateCheckStatus(index)}
            label={topping.name}
            index={index}
          />
        ))}
        <p>
          <pre>{JSON.stringify(toppings, null, 2)}</pre>
        </p>
      </div>
    );
  };
}
export default App;

```

### Query to check if the database is CDB or non-CDB

Suppose you want to know if the target database is CDB (container database ) or Non-CDB ( Normal Non-container database). You can log in to the DB Box and source the Oracle DB and then find using the below query

```
sqlplus / as sysdba
SELECT NAME, CDB, CON_ID FROM V$DATABASE;

NAME CDB CON_ID
--------------------------- --------- ----------
CDB01 YES 0
```

### how to check container database in oracle 12c

Query to check containers in the CDB database. Each PDB and root is a container

```
SQL> alter session set container=CDB$ROOT;

Session altered.

SQL> select CON_ID, NAME, OPEN_MODE, TOTAL_SIZE from v$containers;

CON_ID NAME OPEN_MODE TOTAL_SIZE
---------- -------------------- ------------------------------ ----------
1 CDB$ROOT READ WRITE 0
2 PDB$SEED READ ONLY 891289600
3 SEED READ WRITE 1248961280
4 TEST READ WRITE  1248961280
5 TEST2 READ WRITE 1248961280
```

If you are connected to a PDB, it will show that container only

```
SQL> alter session set container=PDB$SEED;
SQL> select CON_ID, NAME, OPEN_MODE, TOTAL_SIZE from v$containers;

CON_ID NAME OPEN_MODE TOTAL_SIZE
---------- -------------------- ------------------------------ ----------
2 PDB$SEED READ ONLY 891289600
```

### Query to check PDB in the CDB database.

Connected to root container

```
SQL> alter session set container=CDB$ROOT;

Session altered.

select CON_ID,DBID,NAME,OPEN_MODE from v$pdbs;

CON_ID DBID NAME OPEN_MODE
---------- ---------- -------------------- ------------------------------
2 5604597646 PDB$SEED READ ONLY
3 823307170 SEED READ WRITE
4 458722011 TEST READ WRITE

SQL> show pdbs

CON_ID CON_NAME OPEN MODE RESTRICTED
---------- ------------------------------ ---------- ----------
2 PDB$SEED READ ONLY NO
3 SEED READ WRITE NO
4 TEST READ WRITE NO
```

Connected to a particular PDB

```
SQL> alter session set container=SEED;

Session altered.

SQL> select CON_ID,DBID,NAME,OPEN_MODE from v$pdbs
2 ;

CON_ID DBID NAME OPEN_MODE
---------- ---------- -------------------- ------------------------------
3 823307170 SEED READ WRITE

SQL> show pdbs

CON_ID CON_NAME OPEN MODE RESTRICTED
---------- ------------------------------ ---------- ----------
3 SEED READ WRITE NO
SQL>
```

### Startup and shutdown of PDB

Connected to root container

```
alter pluggable database test1_tech close;

alter pluggable database test1_tech close immediate;

alter pluggable database test1_tech open;

alter pluggable database test1_tech open read only ;

alter pluggable database test1_tech open force;
```

If the container is set, we can use the below command

```
ALTER PLUGGABLE DATABASE CLOSE IMMEDIATE;
ALTER PLUGGABLE DATABASE OPEN READ ONLY;
ALTER PLUGGABLE DATABASE OPEN FORCE;

ALTER PLUGGABLE DATABASE NOLOGGING;

ALTER PLUGGABLE DATABASE ENABLE FORCE LOGGING;

STARTUP OPEN
STARTUP OPEN READ ONLY
STARTUP RESTRICT OPEN READ ONLY
```

### How to add service in CDB

```
srvctl add service -db CDB01 -service TEST_NEW -pdb TEST
srvctl modify service -db CDB01 -service TEST_NEW -pdb TEST
srvctl remove service -db CDB01 -service TEST_NEW

BEGIN
DBMS_SERVICE.CREATE_SERVICE(
service_name => 'TEST_NEW',
network_name => 'TEST_NEW.com');
END;
/

BEGIN
DBMS_SERVICE.DELETE_SERVICE(
service_name => 'TEST_NEW');
END;
/

SQL> select name, con_id from v$active_services order by 1;

NAME CON_ID
-------------------- ----------
CDB01 1
CDB01XDB 1
SYS$BACKGROUND 1
SYS$USERS 1
TEST 4
seed 3

6 rows selected.
```

### Show command with 12c database

```
show con_name

CON_NAME
------------------------------
CDB$ROOT

show con_id

CON_ID
------------------------------
1
```

### How to close and open all the PDB in a single command

```
alter pluggable database all close immediate;

alter pluggable database all open;
```

### How to drop the pluggable database

```
drop pluggable database pdb3_test including datafiles;
```

### Container storage

With the root container, we have cdb_tablespaces,cdb_data_files shows the tablespace and data files of all the containers in the CDB, and dba_tablespaces,dba_data_files will show the root tablespace and datafiles only

```
alter session set container=CDB$ROOT;

SQL> select tablespace_name, con_id from cdb_tablespaces;

TABLESPACE_NAME CON_ID
------------------------------------------------------------------------------------------ ----------
SYSTEM 1
SYSAUX 1
UNDOTBS1 1
TEMP 1
USERS 1

SYSTEM 2
SYSAUX 2

SQL> select tablespace_name from dba_tablespaces;

TABLESPACE_NAME
------------------------------------------------------------------------------------------ ----------
SYSTEM
SYSAUX
UNDOTBS1
TEMP
USERS
```

When connected to a PDB, cdb_tablespaces,cdb_data_files shows the same information as dba_tablespaces,dba_data_files for the PDB

### How to rename the pluggable database

Here is the sql command to rename the pluggable database

```sql
alter pluggable database TEST rename global_name to TEST1;
```

### How to check for the Local Undo feature in 12.2

Here is the query to check for the Local Undo feature in Oracle database 12.2. This feature enables local undo tablespace for each of the pdb’s

```
COLUMN property_name FORMAT A30
COLUMN property_value FORMAT A30

SELECT property_name, property_value
FROM database_properties
WHERE property_name = 'LOCAL_UNDO_ENABLED';

PROPERTY_NAME PROPERTY_VALUE
------------------------------ ------------------------------
LOCAL_UNDO_ENABLED TRUE
```

### Viewing the History of PDBs

```
COLUMN DB_NAME FORMAT A10
COLUMN CON_ID FORMAT 999
COLUMN PDB_NAME FORMAT A15
COLUMN OPERATION FORMAT A16
COLUMN OP_TIMESTAMP FORMAT A10
COLUMN CLONED_FROM_PDB_NAME FORMAT A15
SELECT DB_NAME, CON_ID, PDB_NAME, OPERATION, OP_TIMESTAMP, CLONED_FROM_PDB_NAME
FROM CDB_PDB_HISTORY
WHERE CON_ID > 2
ORDER BY CON_ID;
```

I hope you like the compilation of these useful Oracle 12c pluggable database commands. Please provide feedback on it and tell me what else can be added to this list

A recursive function is a [function](https://www.javascripttutorial.net/javascript-function/) that calls itself until it doesn’t. And this technique is called recursion.

Suppose that you have a function called `recurse()`. The `recurse()` is a recursive function if it calls itself inside its body, like this:

```js
function recurse() {
    // ...
    recurse();
    // ...
}
```

A recursive function always has a condition to stop calling itself. Otherwise, it will call itself indefinitely. So a recursive function typically looks like the following:

```js
function recurse() {
    if(condition) {
        // stop calling itself
        //...
    } else {
        recurse();
    }
}
```

Generally, you use recursive functions to break down a big problem into smaller ones. Typically, you will find the recursive functions in data structures like binary trees and graphs and algorithms such as binary search and quicksort.

## JavaScript recursive function examples

Let’s take some examples of using recursive functions.

### 1) A simple JavaScript recursive function example

Suppose that you need to develop a function that counts down from a specified number to 1. For example, to count down from 3 to 1:

```
3
2
1
```

The following shows the `countDown()` function:

```js
function countDown(fromNumber) {
    console.log(fromNumber);
}

countDown(3);
```

This `countDown(3)` shows only the number 3.

To count down from the number 3 to 1, you can:

1. show the number 3.
2. and call the `countDown(2)` that shows the number 2.
3. and call the `countDown(1)` that shows the number 1.

The following changes the `countDown()` to a recursive function:

```js
function countDown(fromNumber) {
    console.log(fromNumber);
    countDown(fromNumber-1);
}

countDown(3);
```

This `countDown(3)` will run until the call stack size is exceeded, like this:

```bash
Uncaught RangeError: Maximum call stack size exceeded.Code language: JavaScript (javascript)
```

… because it doesn’t have the condition to stop calling itself.

The count down will stop when the next number is zero. Therefore, you add an [if condition](https://www.javascripttutorial.net/javascript-if/) as follows:

```js
function countDown(fromNumber) {
    console.log(fromNumber);

    let nextNumber = fromNumber - 1;

    if (nextNumber > 0) {
        countDown(nextNumber);
    }
}
countDown(3);
```

Output:

```
3
2
1
```

The `countDown()` seems to work as expected.

However, as mentioned in the [Function type tutorial](https://www.javascripttutorial.net/javascript-function-type/), the function’s name is a reference to the actual function object.

If the function name is set to `null` somewhere in the code, the recursive function will stop working.

For example, the following code will result in an error:

```js
let newYearCountDown = countDown;
// somewhere in the code
countDown = null;
// the following function call will cause an error
newYearCountDown(10);
```

Error:

```bash
Uncaught TypeError: countDown is not a functionCode language: JavaScript (javascript)
```

How the script works:

- First, assign the `countDown` function name to the variable `newYearCountDown`.
- Second, set the `countDown` function reference to `null`.
- Third, call the `newYearCountDown` function.

The code causes an error because the body of the `countDown()` function references the `countDown` function name, which was set to `null` at the time of calling the function.

To fix it, you can use a named function expression as follows:

```js
let countDown = function f(fromNumber) {
    console.log(fromNumber);

    let nextNumber = fromNumber - 1;

    if (nextNumber > 0) {
        f(nextNumber);
    }
}

let newYearCountDown = countDown;
countDown = null;
newYearCountDown(10);
```

### 2) Calculate the sum of n natural numbers example

Suppose you need to calculate the sum of natural numbers from 1 to n using the recursion technique. To do that, you need to define the `sum()` recursively as follows:

```js
sum(n) = n + sum(n-1)
sum(n-1) = n - 1 + sum(n-2)
...
sum(1) = 1
```

The following illustrates the `sum()` recursive function:

```js
function sum(n) {
  if (n <= 1) {
    return n;
  }
  return n + sum(n - 1);
}
```

## Summary

- A recursive function is a function that calls itself until it doesn’t
- A recursive function always has a condition that stops the function from calling itself.

JavaScript Recursive Function

# 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 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

My first post frol the cloud.
This is not as hard as I thought it would be.

```sql
select * from tasks
where complexity = 'easy'
order by createdAt asc
```

Mic test one, two, three.

Hello world from the cloud.

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.”

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);
```


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.


Austin Ofor (kwadoskii)

Work