Structure and Syntax of SQL Statements

In this script, we will learn about the common keywords (also known as a clause) used in SQL statements and the general structure and syntax of SQL statements.

Keywords identifies the type of operation to be performed. The following are the most common keywords used in SQL statements:

SELECT: Used to retrieve data from one or more tables

INSERT: Used to insert new data into a table

UPDATE: Used to update existing data in a table

DELETE: Used to delete data from a table

ALTER: Used to modify the structure of a table

DROP: Used to delete a table or database object

CREATE: Used to create a new table or database object

USE: Used to select a database to work with

SHOW: Used to display information about a database object

The structure and syntax of SQL statements can vary depending on the specific database management system (DBMS) being used. However, there are some general guidelines that apply to most SQL statements. A basic SQL statement typically consists of the following elements:

Keyword: The keyword or clause that identifies the type of operation to be performed

Arguments: One or more arguments or parameters that provide additional information about the operation to be performed

Semicolon: All SQL statements end with a semicolon (;)

For example, a basic SELECT statement would look like this:

          SELECT column1, column2 FROM table_name;

In this statement, "SELECT" is the keyword, "column1, column2" are the arguments, and "table_name" is the table from which data is being retrieved. The semicolon at the end of the statement indicates the end of the SQL statement.

SELECT statements

An easy example of a SELECT statement in respect with our relational database might look like this:

              SELECT * FROM employees;

  "SELECT" is the keyword and
  "*" and "FROM employees" are the arguments

This SQL statement is retrieving all data from our table called "employees". The * represents all and in this case all columns.

In most cases, however, we do not want all the stored data but only a part of it. For example, the name and the associated phone number of all employees:

          SELECT Name, TelNr FROM employees;

Now let's look at the special arguments FROM and WHERE:

FROM determines the table or tables for this query

WHERE is used to add a condition to your query
        if the condition is a text, enclose the text in single quotes

For example, if we want only the phone number of our employees whose last name is Mouse, then we use:

SELECT Name, TelNr FROM employees WHERE Name = ‘Mouse';

SELECT statements are very powerful and support various insights to Data Scientists. For more special arguments see the annex of this script.

For all software developers, managing the code is an essential part of programming. Version control systems allow developers to control their code changes, collaborate with others, and manage their projects efficiently. A popular version control system is Git, and GitHub is a cloud-based version control service for software development projects built on top of Git.

GitHub provides a user-friendly interface for creating and managing Git repositories, as well as tools for collaborating with other developers on a project. GitHub can be used for both personal and commercial projects and is free in its basic edition.

GitHub can be characterized as a kind of social network for software developers. Members can follow each other, rate each other's work, get updates on specific projects, and communicate publicly or privately. It enables developers to share their work, learn from others, and build a community.
GitHub also provides a comprehensive set of project management tools that make it easy for developers to manage their projects. It includes tools for tracking issues, organizing tasks, and collaborating with others.

GitHub integrates with many other tools and services, including continuous integration and deployment services. This allows developers to automate the process of testing, building, and deploying their code changes.

Since the end of 2018, GitHub Inc is owned by Microsoft.

When working on complex software projects, keeping track of changes and managing multiple versions of code can be a challenging task. Version control systems like.

Git provide a solution to this problem by tracking and recording the changes.
Git provides functionalities to recover old versions of a project, compare, analyse, merge changes, and much more. This process is called version control, and it helps developers keep track of the history of their code. Git is not the only version control system available. Other version control systems like Perforce, Mercurial, CVS, and SVN are also available.

However, Git has become the most popular and widely used version control system among developers due to its flexibility, speed, and ease of use.

One of the unique features of Git is that it is a decentralized version control system. Unlike others, Git doesn't depend on a central server to keep old versions of files. Instead, it works completely locally, storing that data as folders on the user's hard drive. This is called a repository. This allows developers to work on their code offline and makes it easy to track changes without relying on a central server.
If a user wants to work with others on the same code, they can provide a copy of their repository online for the whole team to access. This allows multiple developers to work on the same codebase without overwriting each other's changes

To use Github in a productive way, you need Git on your local computer. There are many Git programs that can be used for free or with a fee:

Windows - “Git for Windows” provides a GUI client and a BASH command line emulator.
https://git-scm.com/downloads/win or
https://gitforwindows.org/

Linux - just open a new terminal and install Git via the package manager of your Linux distribution. For Ubuntu, the command is e.g. sudo apt-get install git

Mac OS - The easiest way is to install homebrew and then just run brew install git from your terminal.
https://brew.sh/ or https://git-scm.com/downloads/mac

Before you can use it, create a Github account on www.github.com. 
There are several configurations to the appearance and functionality of the client. Decide according to your preferences to work efficiently.
However, important is the configuration of the username and the corresponding email address open "Git Bash" and execute these commands on the command
line:

git config --global user.name “Mary”
git config --global user.email “mary.smith@email.eu”

All activities in Git are linked to the respective username and e-mail address specified in the configuration!

This makes modifications traceable because other users always know who made the specific changes and provides overview in projects where many developers are working.

When working with Git, it is essential to understand its terminology to be able to use it effectively.
 

A repository, or repo for short, is a folder in which all files and their version histories are stored. It is the central location for managing and organizing code. A repository can be hosted on a remote server, such as GitHub or Bitbucket, or it can be stored locally on your computer.

A branch is a workspace in which you can make isolated changes that won’t affect others and has its own history. It is like a separate timeline in which you can experiment with changes without affecting the main codebase. Developers can work on different branches simultaneously, making it easier to collaborate and avoid conflicts.
 

A commit is a saved record of modifications made to a file within the repo. It is the state of our repository at a point in time. A snapshot to which the code can be restored. Commits are essential in Git because they allow you to track changes over time and revert to a previous version of your code if necessary.

After updates are made to a repository, other developers can download all changes with a pull request or PR. A pull request is a request to merge changes from one branch into another.
 

This allows developers to review and approve changes before they are merged into the main codebase.
 

Push is the process of adding a local change to the remote repository. When you push your changes, they become available for others to see and download. This is an essential step in collaborating with other developers.
 

After a pull request is approved, the commit will be merged from one branch to another. Merging combines changes from one branch into another, typically the main branch. This process ensures that all changes are incorporated into the main codebase.
 

A clone is a fully functional copy of a project. Copying a repository from a remote server is cloning. This allows you to have a complete copy on the local machine, making it easier to work on your code without relying on an internet connection

When using Git, first a folder must be created mkdir learning-git (=make directory) in which the repository can be created for each program or project cd learning-git (=change directory)

git init

Following this, you can link a local and an online repo with git remote add origin
 

https://github.com/[username]/[projectname].git

Git works with the concept of a "staging area“. At the beginning, the staging area is empty. Files can added (or even single lines and parts of files) with the git add command and finally commit everything (create a snapshot) with git commit:

git add learning_script.txt
git commit –m «firstsnapshot»

To upload code to a remote repo, first connect to it git remote add origin https://github.com/learning.git
 

Then, the local commits can be transferred to the server, performed each time we want to update the remote repository git push server_origin local_master
Once this is done, other developers can download the changes from the remote repository with a single command git pull origin master.

To clone a whole program or project use git clone https://github.com/tutorial.git

When developing a new feature in software development, it is best practice to work on a copy of the original project, called a branch. A branch is a separate copy of the codebase that allows developers to make changes without affecting the live version of the code.
Each branch has its own history and isolates the changes made to it from other branches until it is decided to merge them. The benefits of this approach are:

1. A stable (live) version of the code is not affected by unwanted bugs: When working on a separate branch, any bugs or errors that occur during the development process do not affect the live version of the code.

2. A team of developers can work on many features at the same time: Branches allow multiple developers to work on different features at the same time without interfering with each other's work.

3. Every developer can work on their own branch without the risk of having their codebase changed by another developer's work: Working on separate branches ensures that developers can work independently and avoid conflicts between their code changes.

4. Multiple versions of the same feature can be developed on different branches and then compared to find out the best version: Branches enable developers to experiment with different approaches to a feature and compare the results before merging the changes into the main codebase.
 

In summary, using branches is a best practice in software development as it helps to avoid conflicts and errors, enables teamwork, and allows for experimentation and comparison of different approaches to a feature.
 

The default branch of each repository is called master. To create more branches, use the command git branch <name>
 

Switch to the newly created branch by using

git checkout <name>
To merge two branches switch to one and use git merge <name>
To delete a branch use
git branch –d <name>

In conclusion, many companies are using GitHub. So, if you're looking for a job, you'll do well if you're already familiar with GitHub. GitHub is also a learning and collaboration platform.

Explore it and expand your knowledge and community.