DEV Community: sanadiqbal

DJANGO CONCEPTS

sanadiqbal — Tue, 04 Apr 2023 11:43:53 +0000

1. Settings file

Secret Key

The secret key is a unique string of characters used for cryptographic signing in Django. It is used to secure cookies, user sessions, and other sensitive data. The secret key should be kept confidential and never shared with others. In Django, the secret key is defined in the settings.py file.

Default Django Apps

Django comes with several default apps that are included in the settings.py file by default. These apps are:

django.contrib.admin: A web-based administration interface for managing the site.
django.contrib.auth: User authentication and authorization.
django.contrib.contenttypes: A framework for content types.
django.contrib.sessions: User session management.
django.contrib.messages: A messaging framework for displaying messages to users.
django.contrib.staticfiles: Framework for managing static files.

There are also many third-party apps available for Django that can be added to the settings.py file to extend its functionality.

Middleware

Middleware is a framework that sits between Django's request and response objects and can perform various functions. It can be used for authentication, logging, compression, and security. There are many types of middleware available for Django, some of which are:

AuthenticationMiddleware: Adds the user object to the request.
CSRFMiddleware: Prevents cross-site request forgery attacks.
SessionMiddleware: Adds session management to the request.
XFrameOptionsMiddleware: Prevents clickjacking attacks.
SecurityMiddleware: Provides various security features such as SSL redirection, content type options, and HSTS.

Django Security

Django provides several security features that help prevent common web application vulnerabilities. These include:

Cross-Site Request Forgery (CSRF): Django uses a CSRF token to prevent CSRF attacks.
Cross-Site Scripting (XSS): Django's template system automatically escapes user input to prevent XSS attacks.
Clickjacking: Django's XFrameOptionsMiddleware provides protection against clickjacking attacks.

WSGI

WSGI stands for Web Server Gateway Interface. It is a specification for how web servers and web applications communicate with each other. In Django, WSGI is used to connect the web server to the Django application.

2. Models file

OnDelete Cascade
OnDelete Cascade is a feature of Django models that automatically deletes related objects when an object is deleted. It is useful for maintaining data integrity in the database.

Fields and Validators

Django provides many built-in fields and validators for creating models. Fields include integers, strings, dates, and files, among others. Validators are used to validate data entered by users, such as email addresses or phone numbers.

Python Module vs. Python Class

In Python, a module is a file that contains Python code, while a class is a blueprint for creating objects. In Django's models.py file, classes are used to define database tables.

3. Django ORM

ORM Queries in Django Shell

Django Shell is a command-line interface for working with Django's ORM. It can be used to test queries and run scripts. To use the ORM in the Django Shell, simply import the model and run a query.

ORM to SQL in Django Shell

Django's ORM can be converted to SQL by calling the query method on a queryset. This will return the SQL query that the ORM would generate for the given queryset.

Aggregations

Aggregations in Django are used to perform calculations on a set of objects, such as counting or averaging. Examples of aggregations include Sum, Count, and Avg.

Annotations

Annotations in Django are used to add calculated fields to a queryset. They can be used to perform complex calculations or to aggregate data from related models.

Migration files

A migration file is a Python script that defines changes to your database schema. When you make changes to your Django models, you create a new migration file to record those changes. Migration files are used to synchronize the database schema with the current state of your models.

SQL transactions

A SQL transaction is a sequence of SQL statements that are executed as a single unit of work. Transactions ensure that database operations are performed atomically, meaning that either all of the statements are executed successfully or none of them are executed at all.

Atomic transactions

In Django ORM, atomic transactions are a way to ensure that a sequence of database operations are executed atomically. If any of the operations fail, the entire sequence is rolled back. This ensures that the database remains in a consistent state even if there are errors during the sequence of operations.

REVISION 03-03-2023

sanadiqbal — Fri, 03 Mar 2023 05:39:10 +0000

1. In CSS there is a property called opacity, what does it do?

Opacity refers to the degree to which the content is transparent or opaque. We can use the property named opacity which takes the values ranging from 0 to 1. 0 specifies that the element is completely transparent where 1 means that the element is completely opaque.

2. How do you create a new branch and check in at the same time?

We can create and switch to a new branch in git by the following command.

git checkout -b new_branch

3. What is the difference between div and span tags in HTML?

The

tag is a block-level element that is used to group other elements together and create a block-level box, while the tag is an inline-level element that is used to apply styles to a small piece of text or a section of text within a larger block-level element.

4. How do you handle errors in Python?

In Python, you can handle errors using a try-except block. The code that might cause an error is placed in the try block, and any errors that occur are caught in the except block. We can also use a finally block to ensure that certain code is executed, regardless of whether an error occurred.

5. What is the difference between the append and extend methods of a list in Python?

The append method adds a single element to the end of a list, while the extend method adds multiple elements to the end of a list. For example:

my_list = [1, 2, 3]
my_list.append(4)
print(my_list) # [1, 2, 3, 4]
my_list.extend([5, 6])
print(my_list) # [1, 2, 3, 4, 5, 6]

6. What is the difference between a compiler and an interpreter?

A compiler and an interpreter are both programs that translate code from one programming language into another form, but they differ in how they execute the code and produce results.
A compiler is a program that translates source code into an executable machine code or bytecode that can be directly executed by a computer's processor. The compiler takes the entire program as input, analyzes it, and generates an output in the form of an executable file. The executable file can be run multiple times without the need to recompile the source code. C, C++, Java are examples of programming languages that use compilers.
An interpreter, on the other hand, is a program that reads source code line by line and executes it on-the-fly. Interpreters do not generate a standalone executable file but rather interpret the code and execute it directly. The interpreter translates each line of code into machine code or bytecode and executes it immediately. Python, Ruby, and PHP are examples of programming languages that use interpreters.

7. What is the difference between Normalized CSS and CSS Reset?

Reset CSS: CSS resets aim to remove all built-in browser styling. For example margins, paddings, font-sizes of all elements are reset to be the same.
Normalize CSS: Normalize CSS aims to make built-in browser styling consistent across browsers. It also corrects bugs for common browser dependencies.

8. What is the difference between display: none and visibility: hidden in CSS?

"Display: none" completely removes the element from the page layout, making it invisible and not taking up any space on the page. This means that the element will not be visible and will not affect the layout of other elements on the page.
"Visibility: hidden", on the other hand, hides the element while still taking up space in the layout of the page. This means that the element is not visible, but it still affects the layout of other elements on the page.

9. What is the use of virtual environment in Python?

A virtual environment in Python is a tool that allows you to create an isolated environment for your Python project, separate from your system's Python environment. This isolated environment can have its own set of dependencies, packages, and Python interpreter version.
The main use of virtual environments is to avoid version conflicts between different projects or system-wide dependencies. If we have multiple projects that require different versions of the same package or library, a virtual environment can help you manage these dependencies without causing conflicts.
Virtual environments helps us to create reproducible environments. By specifying the exact versions of dependencies and packages needed for a particular project, we can ensure that the project runs consistently, regardless of the environment it's deployed in.

10. What is the difference between primary key and foreign key in sql?

A primary key is a column or a set of columns in a table that uniquely identifies each row in the table. It is used to enforce data integrity and to establish relationships between tables. A primary key cannot have null values, and each value in the primary key column(s) must be unique.
A foreign key is a column or a set of columns in a table that refers to the primary key of another table. It is used to establish a relationship between two tables and enforce referential integrity. A foreign key can have null values, which means that the column can have values that do not match any primary key values in the referenced table.

11. How do you remove a file from a git repository and retain it in the local machine?

To remove a file from Git without deleting it from the file system, we can use the git rm command with the --cached flag. This will remove the file from the Git repository, but leave it intact on our local file system. For example:

git rm --cached myfile.txt

We can then commit the removal with the git commit command:

git commit -m "Removed myfile.txt from Git repository"

12. What is the difference between Union and Union all ?

UNION and UNION ALL are used to combine the results of two or more SELECT statements. The difference between them is that UNION removes duplicate rows from the result set, while UNION ALL does not.

HTML-CSS

sanadiqbal — Thu, 02 Mar 2023 07:02:48 +0000

HTML

HTML stands for Hypertext Markup Language. It's the standard markup language for Web pages.By using HTML we can create websites.We should remember that html is not a programming language but a markup language.

CSS

CSS stands for Cascading Style Sheet.It's a Style Sheet language that is used for describing the presentation of a document written in a markup language like html.
So CSS is basically just a language we use to style our HTML documents.CSS describes how HTML elements should be displayed.

Some of the key concepts of html and CSS are:

Box Model
Inline versus Block Elements.
Positioning
CSS structural classes
CSS styling classes
CSS Specificity
CSS Responsive Queries
Flexbox
Grid
Common header meta tags

Let's look at these topics one by one.

BOX MODEL

The CSS box model is a container that contains various properties like borders, margins ,padding and also the the contents. We use CSS box models to design the layout of web pages. The browser will render every elements as boxes according to the CSS box model.

Various box properties are:

Content Area: Content area contains all the contents like text, images, or other media content. It is bounded by content edge. The dimensions of content area are given by content-box width and height.
Padding Area: Padding area has the padding of the element. This area is actually the space around the content area and inside the border-box. The dimensions of padding area are given by the width of the padding-box and it's height.
Border Area: Border area is the area between the box’s padding and margin. The dimensions of border area are given by the width and height of the border.
Margin Area: Margin area is the space between border and margin. It's dimensions are the margin-box width and the margin-box height. It functions to separate the element from their neighbouring elements. Let's look at box model with an example. Suppose we have
wrapped inside

<div>
    <p>Some content within the box. Some other contents.</p>
  </div>

We can apply this CSS to

and set size of padding, border, and margin of the element:

  div {
    background-color: yellow;
    padding: 1px;
    border: 1px solid black;
    margin: 0;
  }
  p {
    background-color: white;
    padding: 1em;
    border-width: 10px;
    border-style:solid;
    border-color: red;
    margin: 10px ;
   }

The resulting layout will look like this :

INLINE AND BLOCK ELEMENTS

Each and every element in HTML has a default display value,which depends on the type of the element.

The two display values are:

block
inline

Block elements : A block-level element always starts on a new line, and our browser add some space automatically before and after the element.A block-level element will always take up the full width that is available.Examples of block elements are <p> and <div>.
The <p> element defines a paragraph in the HTML document.
The <div> element defines a division in the HTML document.

Inline-elements: Inline elements do not start on a new line unlike block elements. Inline elements only takes up the necessary width. Examples of inline elements are <a>, <strong>, <b> and <span>.

POSITION

The position property specifies the type of position method which we use to position our elements using CSS.

There are total 5 different position values:

static
relative
fixed
absolute
sticky

We'll discuss only absolute and relative positioning.

Relative positioning : When the position property of an element is relative;any change in position like margin will cause it to adjust from its normal position. The other objects or elements will not fill the gap.

Absolute Position : An element with position: absolute; will cause it to adjust its position with respect to its parent. If no parent is present, then it uses the document body as parent.

CSS SPECIFICITY

When more than one set of CSS rules are applied to a given element, the browser will decides which specific set will be applied to the element. The rules followed by the browser are collectively called Specificity.

CSS Specificity Rules

CSS style applied by referencing external stylesheet has the lowest precedence and it gets overridden by Internal and inline CSS.
Internal CSS gets overridden by inline CSS.
Inline CSS has the highest priority and it overrides all the other selectors.

Specificity Hierarchy

Inline style: Inline style has the highest priority.
Identifiers(ID): Identifiers have the second highest priority.
Classes, pseudo-classes and attributes: Classes, pseudo-classes and attributes are comes after ID.
Elements and pseudo-elements: Elements and pseudo-elements have the lowest priority in CSS.

CSS RESPONSIVE QUERY

We use Media query in CSS is used to make a responsive web design. The view of a web page will differ from system to system based on screen or media types. The breakpoint specifies for what device-width size, the content is just starting to break or deform.

Media queries checks the following:

width and height of the viewport
width and height of the device
Orientation
Resolution

A media query consists of a media type that can has one or more expression which can either be true or false. The result of the query is true if the specified media matches the type of device the document is displayed on and hence a style sheet is applied.
Syntax:

@media not|only mediatype and (expressions) {
  CSS-Code;
}

Media Types in CSS

all: Used for all media devices
print: Used for printer.
screen: Used for computer screens, smartphones, etc.
speech: Used for screen readers that read the screen out aloud.

FLEXBOX

Flexbox is a CSS display type which helps to help us create CSS layouts very easily and very fast.It controls the position, size and spacing of elements relative to their parents elements as well as each other.
Flexbox is ideal for responsive web designing.
When we apply a display type of flexbox to a parent container, all the child elements in it are adjusted into the flex type and these child elements are now called the “flex items”. Now they have become more flexible i.e. we can control how much they will shrink and how much they will grow and we can also control the spacing between these elements.

Properties of flexbox

display : Display defines a flex container
flex-direction : It defines the main axis
flex-wrap: It allows flex items to wrap on more than one line.
flex-flow It's shorthand for flex-direction + flex-wrap.
justify-content: It allows items to align along the main axis.
align-content Allows items to align along cross axis in a single line.It aligns multiple lines of items on the cross axis. Let's look at an example.

<div class="parent">
  <div class="child">A</div>
  <div class="child">B</div>
  <div class="child">C</div>
</div>

.child{
 width:50px;
 height:50px;
 background:red;
}

Output:

After applying flexbox on parent class.

.parent{
 display:flex;
}
.child{
 width:50px;
 height:50px;
 background:red;
}

Output:

Changing the flex-direction to column:

.parent{
 display:flex;
  flex-direction:column;
}
.child{
 width:50px;
 height:50px;
 background:red;
}

Output:

Using justify content to align the items along main axis.

.parent{
 display:flex;
  justify-content:space-between;
}
.child{
 width:50px;
 height:50px;
 background:red;
}

Output:

GRID

Grid layout module in CSS is used to create a grid-based layout system, with the help of rows and columns that makes it much easy to design a web page without using floats and positioning.

Syntax

.class {
    display:grid;
}

Grid Properties

grid-template: Shorthand property for defining grid columns, rows, and areas.
grid-template-areas: Used to specify the area within the grid layout.
grid-template-columns: Used to set the number of columns and size of the columns of the grid.
grid-template-rows: Used to set the number of rows and height of the rows in a grid.
column-gap: Used to specify the amount of gap between the columns in which a given text is divided using the column-count property.
gap: Used to set the spacing also caller gutter between the rows and columns.
grid-column: Describes the number of properties that allow to design of grid structures and control the placement of grid items using CSS.
grid-column-end: Explains the number of columns an item will span, or on which column-line the item will end.
grid-column-gap: Used to set the size of the gap between the columns in a grid layout.

Let's understand it with an example.

<div class="parent">
  <div class="child A">A</div>
  <div class="child B">B</div>
  <div class="child C">C</div>
</div>

.parent{
 display:grid;
 grid-template-rows:1fr 1fr 1fr;
 grid-template-columns:1fr 1fr 1fr;

 }
.child{
 width:50px;
 height:50px;
 background:red;
}
.A{
 grid-column:3/4;
 grid-row:1/2;
}
.B{
  grid-column:1/2;
 grid-row:3/4;
}
.C{
   grid-column:2/3;
 grid-row:2/3;
}

COMMON HEADER META TAGS

Meta Tag is an HTML component which gives the metadata about an HTML document. It is an empty tag, it just has an initial tag and no end tag. It's always present inside the

tag and are used to portray Page portrayals, Certain Keywords, Author of the Document, viewport settings, determining character sets, and so on.
They are used by Web Browsers, Search Engines, and other Web Services to rank the web pages accordingly.

<head>
   <meta attribute-name = "value"/>
</head>

Attributes

name: Used for indicating the character encoding for the HTML Document.
http-equiv: Used to get the HTTP response message header.
content: Used to specify properties value.
charset: Used for indicating the character encoding for the HTML Document.

CSS STRUCTURAL CLASSES

CSS structural classes are classes used to target and apply styles to specific structural elements of a webpage, such as headings, paragraphs, lists, tables, and forms. These classes are used to create consistent styles throughout a website and make it easier to update styles in the future.

Here's an example of how to use structural classes in CSS:

h1, h2, h3, h4, h5, h6 {
  font-size: 24px;
}

.content p {
  background-color: #eee;
}

.table {
  border: 1px solid black;
}

.input {
  border-radius: 5px;
}

In this example, we use the following structural classes:

h1, h2, h3, h4, h5, h6 to target all headings and apply a font size of 24px.
.content p to target all paragraphs within a div with class content and apply a background color of #eee.
.table to target all tables with class table and apply a border of 1px solid black.
.input to target all form inputs with class input and apply a border radius of 5px.

By using these structural classes, we can easily apply consistent styles throughout our website and make it easier to update styles in the future.

CSS STYLING CLASSES

CSS styling classes are classes used to apply specific styles to elements in a webpage. These classes are used to create custom styles that are unique to a particular element or set of elements on the page.

Let's see an example of how to use styling classes in CSS:


.primary {
  background-color: blue;
  color: white;
}
.error {
  color: red;
}
.button:hover {
  border: 1px solid green;
  padding: 5px;
}

In the above example, we use the following styling classes:

.primary to apply a blue background color and white text color to any element with the class primary.
.error to apply a red text color to any element with the class error.
.button:hover to apply a green border and padding to any element with the class button when it is hovered over by the user.

By using these styling classes, we can create custom styles that are unique to specific elements or sets of elements on the page. This allows us to have more control over the appearance of our webpage and make it more visually appealing to our users.

REFERENCE

SQL CONCEPTS

sanadiqbal — Wed, 22 Feb 2023 07:04:22 +0000

SQL

SQL stands for Structured Query Language.It is a database language that is used to create, maintain and retrieve data from relational databases like MySQL,PostgreSQL
etc.We use SQL when data is structured in the from of tables.

Some of the key concepts of SQL are :

ACID
CAP Theorem
Joins
Aggregations, Filters in queries
Normalization
Indexes
Transactions
Locking mechanism
Database Isolation Levels
Triggers

Let's see them one by one.

ACID

A transaction is a single logical unit of work which assess and if also may modify the contents of a database. Data is accessed by transaction using read and write operations.
In order to maintain consistency in a database before and after transaction certain properties are followed.These properties are called ACID.

ACID is an acronym for :

A : Atomicity
C : Consistency
I : Isolation
D : Durability

Atomicity : This property states that either the entire transaction takes place or it does not happen at all.
No transaction occurs partially. Atomicity involves two operations :

Abort : If a transaction aborts,then changes made to the database are not visible.
Commit : If a transaction commits, changes made to the database are visible.

Consistency : Consistency means that the database must be consistent before and after the transaction. It refers to the correctness of the database.

Isolation : Isolation properties ensures multiple transaction can occur at the same time without disturbing the consistency of the database. All the transactions take place independently without affecting other transactions. Changes occurring in one transaction will not be visible to other transactions until it is comitted.

Durability : This property states that changes made to the database after a transaction are stored in disc and they should persist even if the system fails. Therefore the changes made by the transaction are never lost.

CAP THEOREM

CAP theorem states that it is not possible to guarentee all the three desired properties : Consistency,Availability and Partition tolerance at the same time in a distributed system with data replication.
It states that any network shared data system can support only two of the three properties.

Consistency : Consistency means all the nodes will have the same copy of the replicated data item for different types of transactions. All the clients should have the same view of the data. Consistency in CAP refers to sequential consistency.

Availability : Availability means that all the read and write requests for a data item will either be processed successfully or the user must receive a message that the operation could not be completed. Every non failing node must return a response for every read and write request in a reasonable amount of time.

Partition tolerance : Partition tolerance means that the system continues operation even if the network connecting the nodes has a fault that results in two or more partition, where the nodes in each partition can only communicate with each other. This means system continues to function despite of network partitions.

JOINS

Joins in SQL are used to combine two or more rows between two or more tables based on some common field between them.
Different type of joins are :

INNER JOIN
LEFT JOIN
RIGHT JOIN
FULL JOIN

Consider the tables below :

students

Roll_number	Name	Address	Phone	Age
1	Tom	Delhi	123	18
2	Tim	Kolkata	432	18
3	Rahul	Patna	999	19
4	Ranjan	Gaya	787	18

studentcourse

Course_id	Roll_number
12	1
12	2
16	9
17	8

INNER JOIN : Inner join or simply join selects all the rows from the left and the right table as long as condition is satisfied.

select
    studendcourse.courseid as courseid,
    studentcourse.Roll_number
     as Roll_number,
    students.name
    as name
from
    studentcourse
    join students on
 students.Roll_number = 
studentcourse.Roll_number;

Output

courseid	Roll_number	name
12	1	Tom
12	2	Tim

Left join :Left join returns all the rows of the table on the left side of the join and matches rows for the table on the right side of the join.

select
    studendcourse.courseid as courseid studentcourse.Roll_numberas Roll_number 
students.name as name
from
    studentcourse
    left join students on students.Roll_number = studentcourse.Roll_number;

Output

courseid	Roll_number	name
12	1	Tom
12	2	Tim
16	9
17	8

Right join : Right join returns all the rows on the right and matching rows on the left.

    studendcourse.courseid as courseid,
    studentcourse.Roll_numberas Roll_number,
    students.name as name
from
    studentcourse
    right join students on 
    students.Roll_number =
 studentcourse.Roll_number;

Output

courseid	Roll_number	name
12	1	Tom
12	2	Tim
	3	Rahul
	4	Ranjan

Full join : Full join combines the results of both left join and right join. The resulting output will have all the values from both the tables.

select
    studendcourse.courseid as courseid,
    studentcourse.Roll_numberas Roll_number,
    students.name as name
from
    studentcourse
    full join students on 
    students.Roll_number =
 studentcourse.Roll_number;

Output

courseid	Roll_number	name
12	1	Tom
12	2	Tim
	3	Rahul
	4	Ranjan
16	9
17	8

AGGREGATE FUNCTIONS AND FILTERS

Aggregate functions in SQL are functions where the values of multiple rows are grouped together as input on certain criteria to give some results.

Some of the Aggregate functions in SQL are :

Count()
Sum()
Avg()
Min()
Max()

Let's understand them one by one with the help of the table below :

employee

Id	Name	Salary
1	Ram	1200
2	Rahul	1300
3	Ranjan	1500

Count() : Count returns the count of column elements that matches the given conditions.

select
    count(*)
from
    employees

Output
3

Sum() : Sum() returns the sum of all column elements that satisfies the given conditions.

select
    sum(salary)
from
    employees

Output
4000

Avg() : Avg() returns the average value of all the column elements satisfying the given conditions.

select
    avg(salary)
from
    employees

Output
1333
Max() : Max() returns the maximum value from all the column elements satisfying the given conditions.

select
    max(salary)
from
    employees

Output
1500

Min() : Returns the minimum value from all the column elements satisfying the given conditions.

select
    min(salary)
from
    employees

Output
1200

FILTERS
SQL allows filtering of data using various queries.Filtering can be done using these clauses:

GROUP BY
HAVING

Let's understand them with examples

IPL

Year	Matchid	Winner
2017	1	kkr
2017	2	kkr
2017	3	csk
2018	4	rcb
2018	5	rcb
2018	6	csk
2019	7	kkr
2019	8	csk
2019	9	csk

GROUP BY : GROUP BY statement groups together the values that satisfies the given condition or have the same values.

select
    winner as team,
count(*) as matches_won
from
    ipl
group by
    winner

Output

team	matches_won
kkr	3
csk	4
rcb	2

HAVING : HAVING clause is used when we want to use functionality of WHERE when using GROUP BY.

select
    winner as team,
    count(*) as matches_won
from
    ipl
group by
    winner
having
    matches_won > 3

Output

team	matches_won
csk	4

NORMALIZATION

Normalization is a stepwise process which allows us to decompose database tables in such a way that both data dependency and update anomalies are minimized. It uses the functional dependency existing in the table and primary key or candidate key in analyzing the tables.

Different normal forms are :

1NF : Given relation is in 1NF if it contains an atomic
value.

2NF : Given relation will be in 2NF if it is in 1NF and
all non-key attributes are fully functional
dependent on the primary key.

3NF :Given relation will be in 3NF if it is in 2NF and no
transition dependency exists.

BCNF: Stronger definition of 3NF is known as Boyce Codd's
normal form or BCNF.

4NF : Given relation will be in 4NF if it is BCNF and has
no multi-valued dependency.

5NF :Given relation is in 5NF,if it is in 4NF and does
not contain any join dependency, joining must always
be lossless.

INDEXES

An index is a pointer to data in an SQL table.Indexes are special lookup tables which the database search engine uses to speed up the data retrieval. Index in a database is kind of like an index in the back of a book.

Creating index command

CREATE INDEX index_1 ON employee;

Creating index column command

CREATE INDEX index_1
ON employee (emp_id);

Creating Unique indexes

Unique index does not allow duplicate values to be inserted into the table.

CREATE UNIQUE INDEX index_1
on  employee(id);

Creating Composite index

A composite index is an index made from two or more columns.

CREATE INDEX index_1
ON employee (emp_id,name);

Dropping the index command

DROP index index_1

TRANSACTION

Transactions are basically group a set of tasks into a single execution unit. Every transaction starts with one task and ends when all the tasks in the group successfully complete. If any one of the tasks fail, the transaction will fail. Hence, a transaction has only two results: success or failure.
Implemeting transaction using SQL:

Begin transaction

It indicates the starting point of a local transaction.

BEGIN TRANSACTION transaction_1 ;

Set transaction

SET TRANSACTION [ READ WRITE | READ ONLY ];

Commit

Commit command saves all the transactions to the database since the last COMMIT.

COMMIT;

Rollback

Rollback is the process of reversing changes. This command can only be used to undo transactions since the last COMMIT or ROLLBACK command was issued.

ROLLBACK;

LOCKING MECHANISM

Locking is a mechanism which is associated with a table for restricting unauthorized access to the data. It is mainly used to solve the concurrency problem in transactions.Locking can applied on to row level, database level, table level, and page level.
Data consistency is really important in SQL , and it can be done by means of SQL Locks. A lock gets established in SQL Server when a transaction gets started, and is released when the transaction ends.

Shared (S) Locks: This type of lock occurs when we want to read something.
Exclusive (X) Locks:This lock prevents any type of modification.It prevents transactions like inserting,updating or deleting.

DATABASE ISOLATION LEVELS

Database isolation determines how transaction integrity is visible to other users.
Transaction must take place in a system such that it's the only transaction accessing the resources in a given database system.
Database isolation levels define the degree to which a transaction should be isolated from the data modifications made by any other transaction in the database system.

SQL standards has defined 4 isolation levels:

Read Uncommitted : It's the lowest isolation level. At
this transaction level, transactions are not isolated from one other.
Read Committed : This level ensures that any data read is
committed at the moment it is being read.
Repeatable Read: This is the most restrictive isolation
level. The transaction holds read locks on all rows it references and writes locks on referenced rows for update and
delete actions.
Serializable : It's the highest isolation level. Serializable execution is basically an execution of operations in which concurrently executing transactions
appears to be serially executing.

TRIGGERS

A trigger is a stored procedure in database which gets automatically invoked whenever a special event in the database occurs.A trigger may be invoked when a row is inserted into a specified table or when certain table columns are being updated.

create trigger [name] 
[before | after]  
{insert | update | delete}  
on [table_name]  
[for each row]  
[trigger_body]

create trigger [ name ] : This will create a trigger of the given name.

[ before | after ] : This specifies when the trigger that we made gets executed.

{ insert | update | delete } : This specifies the operation.

on [ table_name ] : This specifies the name of the table on which the trigger is made.

[ for each row ] : This specifies a row level trigger.

[ trigger_body ] : This specifies the operations that will be performed when the trigger gets fired.

REFERENCES

SOLID Principles

sanadiqbal — Mon, 20 Feb 2023 07:01:25 +0000

The SOLID principles are the five important principles of Object Oriented class design.Put simply, they are set of rules that every developer should follow while designing class structures.The main purpose of SOLID principles is to create understandable,readable and testable code that many developers can collaboratively work on.
The five SOLID principles are:

Single Responsibility principle
Open-Closed principle
Liskov Substitution principle
Interface Segregation principle
Dependency Inversion principle

Let's look at these principles one by one with Python codes.

Single Responsibility Principle

The Single Responsibility principle states that every class, module and function in a program should have one single responsibility/purpose in that program and therefore should have only one reason to change.

Let's look at a code :

class Employeee:

    def send_email(self):
        pass
    def employee_performance(self):
        pass

The above code violates the Single responsibility principle as the employee class performs two responsibilities, sending email and assessing employee's performance.
Let's fix this code so that it follows SRP.

class EmployeeEmail:
   def send_email(self): 
       pass

class Employeeperformace:
   def employee_performance(self):
       pass

Open Closed Principle

The Open Closed Principle states that the classes should be open for extension but closed for modification. This means that the class should be made in such a way that their core functionality can be extended to other classes without altering the initial class's source code.

class PersonStorage:

    def savetodatabase(self, person):
        print('saved the {} to database'.format(person))

    def savetojson(self, person):
        print('saved to {} json '.format(person))


if __name__ == '__main__':
    p1 = 'Sam'
    storage = PersonStorage()
    storage.savetodatabase(p1)

In the above code suppose we want to save the person to XML file. It's not possible without modifying the class PersonStorage. So the above class is open to modification but closed to extension. Hence it does not follow OCP.

from abc import ABC, abstractmethod


class PersonStorage(ABC):

    @abstractmethod
    def save(self, person):
        pass


class PersonDB(PersonStorage):

    def save(self, person):
        print(f'Save the {} to database'.format(person))


class PersonJSON(PersonStorage):

    def save(self, person):
        print(f'Save the {} to a JSON file'.format(person))


class PersonXML(PersonStorage):

    def save(self, person):
        print(f'Save the {} to a XML file'.format(person))

To solve the problem, we first created an abstract class PersonStorage and create an abstract method save in it.
After that we create a class for each saving type which inherits the abstract class PersonStorage. After that we override the save function everytime we create a new class.
Now our code follows OCP.

Liskov Substitution Principle

Liskov principle states that the object of a class should be able to be substituted by the object of it's subclass without
changing the code's correctness. This means that when an instance of a class is passed to another class, the child class must have a use case for all the properties and behaviour of the parent class .Let's look at some codes to understand this.

class Notification(ABC):
    @abstractmethod
    def notify(self, message, email):
        pass


class Email(Notification):
    def notify(self, message, email):
        print(f'Send {message} to {email}')


class SMS(Notification):
    def notify(self, message, phone):
        print(f'Send {message} to {phone}')

The above example violates Liskovs Substitution principle as the as the notify method in SMS class takes phone as input instead of email.

from abc import ABC, abstractmethod

class Notification(ABC):
    @abstractmethod
    def notify(self, message):
        pass
class Email(Notification):
    def __init__(self, email):
        self.email = email

    def notify(self, message):
        print(f'Send "{message}" to {self.email}')
class SMS(Notification):
    def __init__(self, phone):
        self.phone = phone

    def notify(self, message):
        print(f'Send "{message}" to {self.phone}')

To conform to the Liskov principle first we removed email as an argument from Notification abstract class. Then we made init method in both email and SMS class taking email and SMS respectively as the arguments.

Interface Segregation Principle

Interface Seggregation Principle states that the interface of a program should be split in such a way that the user has access to only the methods of their needs and they don't have to deal with unnecessary or complex methods which are of no use to them.Let's understand it with the help of code.

from abc import ABC, abstractmethod

class Vehicle(ABC):
    @abstractmethod
    def go(self):
        pass
    @abstractmethod
    def fly(self)
        pass

class Car(Vehicle):
    def go(self):
        print('Going on road')

class Airplane(Vehicle):
    def go(self):
        print('Going on runway')
    def fly(self):
        print('Flying in air')

In the above example notice that the class car has no use of the fly method. Hence Interface Segregation Principle is violated.

from abc import ABC, abstractmethod

class Movable(ABC):
    @abstractmethod
    def go(self):
        pass
class Flyable(Vehicle):
    def fly(self):
        pass

class Car(Movable):
    def go(self):
        print('Going on road')

class Airplane(Flyable):
    def go(self):
        print('Going on runway')
    def fly(self):
        print('Flying in air')

We conformed to ISP by splitting vehicle into two interface movable and flyable.

Dependency Inversion

The Dependency Inversion Principle states that the classes in our function should depend on abstract classes rather than concrete classes.Let's understand it with the help of code.

class shape:
    def length(self):
        pass 
    def width(self):
        pass
    def area(self):
        pass

class rectangle(self):
    def length(self):
        pass
    def width(self):
        pass
    def area(self):
        pass

The above class rectangle violates dependency inversion principle as it depends on a concrete class.

from abc import ABC,abstractmethod
class shape:(ABC)
    @abstractmethod
    def length(self):
        pass 
    @abstractmethod
    def width(self):
        pass
    @abstractmethod
    def area(self):
        pass

class rectangle(self):
    def length(self):
        pass
    def width(self):
        pass
    def area(self):
        pass

To conform to DIP we simply make the shape class as abstract class and all of it's methods as abstract methods.

References

https://www.freecodecamp.org/news/solid-principles-explained-in-plain-english/
https://www.freecodecamp.org/news/solid-principles-single-responsibility-principle-explained/
https://www.pythontutorial.net/python-oop/python-dependency-inversion-principle/
https://www.pythontutorial.net/python-oop/python-interface-segregation-principle/
https://www.pythontutorial.net/python-oop/python-liskov-substitution-principle/
https://www.pythontutorial.net/python-oop/python-open-closed-principle/

OBJECT ORIENTED PROGRAMMING IN PYTHON

sanadiqbal — Thu, 16 Feb 2023 06:38:16 +0000

OBJECT ORIENTED PROGRAMMING

Object Oriented Programming (OOPs) is a programming paradigm where object and classes are used for programming. By Object oriented programming real world entities like inheritance are implemented in programming. The main concept of OOPs is to bind the data and the functions that work together as a single unit so that no other part of the code can access this data.

MAIN CONCEPTS OF OBJECT ORIENTED PROGRAMMING

Class
Object
Polymorphism
Encapsulation
Inheritance
Data Abstraction

CLASS

Class is a collection of objects.It is the blueprint from which objects are created.Class is made up of attributes and methods.Attributes are the variables in the class and methods are the functions inside the class. Making a class does not consume any memory. So basically classes are created to organise data into logical units.

Creating a class in python

# using class keyword we make a class called MyClass
class MyClass:
     pass

OBJECT

Object is an instance of a class.We can think of it as a variable made using the datatype class.Classes are made specifically to create objects.Classes contains all the attributes and methods that it's object will have.
For example if we make a class called student and create attributes for this class.

class Student:
     full_name=str()
     roll=int()
     std=int()
     age=int()

We make an object of this class in our main program.We can access the attributes of the class which are public using the dot operator.Attributes are public.

Raj=Student()
Raj.full_name='Raj Kapoor'
Raj.roll=23
Raj.std=5
print(Raj.roll)
# Output : 23

init method:
init method is basically made to initialise the attributes while the objects are being made.If we don't make an init function the compiler makes one for us by default and it takes no argument.While making the object we initialise it by passing values to it's attributes.The first argument in init while defining it is self.self keyword is used to access the attributes in the class.

class Student():
    def __init__(self,first,last,age_):
        self.first_name=first
        self.last_name=last
        self.age=age_


Raj=Student('Raj','Kapoor',25)

print(Raj.first_name)
# Output : Raj

Creating methods in class
A method in OOPs is a procedure or a function within a class.
Method of an object can only access the attributes of that object.The first argument while defining a method is always self.

class Student():
    def __init__(self,first,last,age_):
        self.first_name=first
        self.last_name=last
        self.age=age_
    def set_email(self):
        email=self.first_name+'.'+self.last_name+'@email.com'
        return email

Raj=Student('Raj','Kapoor',25)

print(Raj.set_email())

#Output : Raj.Kapoor@email.com

INHERITANCE

Inheritance is the capability of one class to inherit properties from another class.The class which inherits the properties is called child class or derived class and the class from which the properties are inherited is called parent class or base class.
The advantages of inheritance in OOPs are :

It represents real world relationship.
Improves the reusability of code.
It's transitive by nature.If a class Q inherits the properties of class P and class R inherits the properties of class Q,then class R automatically inherits the property of class P. *Enhances code readabilty.

Example of inheritance:

class Student():
    def __init__(self,first,last,age_):
        self.first_name=first
        self.last_name=last
        self.age=age_
    def email(self):
        email=self.first_name+'.'+self.last_name+'@email.com'
        return email
class CollegeStudent(Student):
    def __init__(self,first,last,age_,college):
        self.first_name=first
        self.last_name=last
        self.age=age_
        self.college=college


Rahul=CollegeStudent('Rahul','Kapoor',25,'IIT')

print(Rahul.email())

# Output : Rahul.Kapoor@email.com

Types of inheritance

1.Single inheritance : When the child is derived from only on single base class it's called single inheritance.

Example :

class Animal():
    name=str()
    sound=str()

class Dog(Animal):
    def set_sound(self):
        self.sound='woof'



tommy=Dog()
tommy.set_sound()
print(tommy.sound)
# Output : woof

2.Multiple inheritance : One child class derives properties

from more than one base class.

Example :

class Dad:
    def sing():
        print('Good singer')

class Mom:
    def art():
        print('Good artist')

class Son(Dad,Mom):
    pass

Gon=Son()
Son.sing()
Son.art()
 # Output : Good singer
            Good artist

3.Hierarchical inheritance : Multiple child class inherits properties from a single class.

Example :

class Animal():
    name=str()
    sound=str()

class Dog(Animal):
    def set_sound(self):
        self.sound='woof'

class Cat(Animal):
    def set_sound(self):
        self.sound='meow'

tommy=Dog()
snowball=Cat()
snowball.set_sound()
tommy.set_sound()
print(tommy.sound)
print(snowball.sound)

Multilevel inheritance : When a class derives properties from a parent class which itself is a derived class.The class made inherits the properties of it's parent class as well as the parent class of it's parent class.

Example :

class Grandpa : 
    def height(self):
        print('Good height')

class Dad(Grandpa):
    def hair(self):
        print('Good hair')

class Son(Dad):
    def player(self):
        print('Good player')


goku=Son()
print(goku.player())
print(goku.height())
print(goku.hair())

# Output :Good player
#         None
#         Good height
#         None
#         Good hair
#         None

POLYMORPHISM

Polymorphism simply means taking many forms.It enables same method to have different functionalities according to the class it is in.Same method can perform different function in the parent and the derived class as well as in different classes. Polymorphism is implemented in OOPs by duck typing,method overriding and method overloading.
Duck typing : Duck typing means that the type of the object is of concern only during the runtime and we don't need to mention the type of the object before performing any operation on it.Python supports dynamic duck typing.

class Car():
    def sound(self):
        return 'zoom'
class Dog():
    def sound(self):
        return 'woof'

tommy=Dog()
print(tommy.sound())
tesla=Car()
print(tesla.sound())

#Output : woof
#         zoom

Method overriding : Method overriding allows specific implementation of a method in child class that is already present in parent class.

class Car():
    def sound(self):
        return 'zoom'
class SportsCar(Car):
    def sound(self):
        return 'vrooom'

tesla=SportsCar()
print(tesla.sound())
maruti=Car()
print(maruti.sound())

ENCAPSULATION

Encapsulation is the grouping of data and methods that work on the data within a single unit.This puts restriction on accessing the data and methods directly to prevent accidently changing the data. The attributes are made private for this purpose. A class is an encapsulation as it encapsulates all the attributes and methods related to a single thing.

ABSTRACTION

Abstraction is the process of hiding unnecessary complex data from the user that the user has no need of and also hiding sensitive information from the user.
Abstraction is implemented in python by creating abstract class.

from abc import ABC,abstractclassmethod

class Shape(ABC):
    @abstractclassmethod
    def sides(self):
        pass

class Triangle(Shape):
    def sides(self):
        return 3

class Square(Shape):
    def sides(self):
        return 4

abc=Triangle()
print(abc.sides())
pqrs=Square()
print(pqrs.sides())

# Output : 3
#          4

References

OOPs concepts - GeeksforGeeks
Abstract classes - GeeksforGeeks
Method overriding - GeeksforGeeks

PYTHON : STRING METHODS

sanadiqbal — Wed, 15 Feb 2023 09:53:28 +0000

Some of the most important string methods in python are :

capitalize() : Convert the first letter of the given list an uppercase letter and returns a new string.

# String   
s="cat"
# using capitalize()
z=s.capitalize()
print(z)
# Output : Cat

2.casefold() : Returns a string where all the elements are lower case.

# string
s=CAt
# using casefold()
z=s.casefold()
print(z)
# Output : cat

3.center() : Returns a string aligned by the given character spaces.

s=cat
z=s.center(10)
print(z)
# Output :    cat

4.count() : Returns the number of times a given substring has occured in the given string.

s="catcat"
n=s.count('cat')
print(n)
# Output :  2

5.encode() : Encodes the string with the given encoding type.

txt = "My name is Sam."
print(txt.encode(encoding="utf-8",errors="ignore"))
# Output : My name is Sam.

6.endswith() : Returns False if the string does not end with the given substring.

txt="Apple"
print(txt.endswith('le'))
# Output : True

7.find(): Finds the first occurrence of the given substring.

txt='batballcat'
n=txt.find('cat')
print(n)
# Output : 7

8.format() : Formats the given value and insert them inside the string's placeholder.

txt = "I have {x} apples"
print(txt.format(x=20))
# Output : I have 20 apples.

9.format_map() : Formats the given dictionary value and insert the key and the value in the string's placeholder.

a = {'x':'John', 'y':'Doe'}  
# Use of format_map() function
print("{x} {y} is a stranger.".format_map(a))
# Output : John Doe is a stranger.

10.index() : Returns the index occurrence of the first occurrence of the given substring.

a='batcatrat'
print(a.index('rat'))
# Output : 6

11.isalnum() : Checks whether all the characters in the string is alphanumeric or not.

a='batcatrat123'
print(a.isalnum())
# Output : True

12.isprintable() : Checks whether all the characters are printable or not.Also returns True if the list is empty.

a="Hello"
print(a.isprintable())
# Output : True

a="Hello\n"
print(a.isprintable())
# Output : False

13.isnumeric() : Checks whether all the characters are numeric or not.

a='1234'
print(a.isnumeric())
# Output : True

14.islower() : Checks whether all the characters are lowercase or not.

a='Bat'
print(a.islower())
# Output : False

15.isidentifier() : Checks whether the string is valid identifier or not.

a='1234_a'
print(a.isidentifier())
# Output : False

16.isdigit() : Checks whether all the characters are digit or not.

a='1234'
print(a.isdigit())
# Output : True

17.isdecimal() : Checks whether all the characters in the string are decimal or not.

a='12'
print(a.isdecimal())
# Output : True

18.isalpha() : Checks whether all the characters in the string are alphabets or not.

a='abd'
print(a.isalpha())
# Output : True

19.isspace() : Checks whether all the characters in the string are space or not.

a='  '
print(a.isspace())
# Output : True

20.zfill() : Places the given number of zeroes at the left side of string.

z='cat'
x=z.fill(3)
print(x)
# Output : 000cat

21.upper() : Converts all the lowercase characters to uppercase.

z='cAt'
print(z.upper())
# Output : CAT

22.title() : Converts the string to title case.

z='cAt'
print(z.title())
# Output : Cat

23.swapcase() : Converts all the uppercase characters to lowercase and vice versa.

z='cAt'
print(z.swapcase())
# Output : CaT

24.strip() : Removes the space from the beginning and the end of string

z='  cat  '
print(len(z.strip()))
# Output : 3

25.startswith() : Checks whether the string starts with
the given substring.

z='cat'
print(z.startswith('c'))
# Output : True

26.splitlines() : Splits the string where each line ends and returns a list.

txt = "Cat\nMouse"
x = txt.splitlines()
print(x)
# Output : ['Cat', 'Mouse']

27.rpartition() : Returns a tuple with three elements.Takes a string as an input which becomes the middle element of the tuple.

txt = "catMousedog"
x = txt.rpartition("Mouse")
print(x)
# Output : ('cat', 'Mouse', 'dog')

28.rjust() : Right aligns the string by the given width.

txt = "cat"
print(txt.rjust(10))
# Output :       cat

29.rfind() : Returns the highest index of the given substring.

txt='catbatcat'
print(txt.rfind('cat'))
# Output : 6

30.replace() : Replaces all the occurrence of the given substring with the desired substring and returns a new substring.

txt="bznznz"
a=txt.replace('z','a')
print(a)
# Output : banana

31.lstrip() : Removes the spaces from the beginning and returns a string.

txt="  cat "
l=txt.lstrip()
print(len(l))
# Output : 4

32.lower() : Converts all the uppercase letters to lowercase.

txt='CAt'
newtxt=txt.lower()
print(newtxt)

33.join() : Returns a concatenated string.

mytuple=('bat','cat','ball')
space=' '
x=space.join(mytuple)
print(x)
# Output : bat cat ball

PYTHON :LIST METHODS

sanadiqbal — Wed, 15 Feb 2023 06:32:03 +0000

Some of the most important python list methods are :

1.append() : Appends and add value to the end of list.

# Creating the list
l=[1,2,3]
a=5

# Append the value a to the list
l.append(a)
print(l)
# Output : [1,2,3,4]

2.copy() : Returns a copy of the given list.

# List
l=[1,3,5]

# Copying the list value to a new list
l_copy=l.copy()
print(l_copy)
# Output : [1,3,5]

3.count() :Returns the count of elements in the list.

#list
l=[1,7,9]
#using count
n=l.count()
print(n)
# Output : 3

4.sort() :Sorts the list in ascending or descending order.

# list
l=[1,9,8,100]
# Sort in ascending order
l.sort()
#Sorting in descending order
l.sort(reverse=True)

5.reverse() : Reverses the elements of list.

#list
l=[4,3,5,7]
#reversing the list
l.reverse(l)
print(l)
# Output : [7,5,3,4]

6.remove() : Removes the occurrence of the first given value from the list.

# list
l=[2,2,2]
# removing 2 from the list
l.remove(2)
print(l)
# Output : [2,2]

7.pop() : Pops and returns the value of the given argument.If no value is passed,it pops and returns the value at last index.

# list 
l=[2,4,5,7]
# Popping the value at index 1 and storing it in a
a=l.pop(1)
print(a)
# Output : 4

remove() : Removes the first occurrence of the given element from the list.

# list
l=[2,3,4,2]

# Removing 2 from the list
l.remove(2)
print(l)
# Output : [3,4,2]

9.insert() : Inserts the given value at the given index.

#list
l=[9,8,7]
# inserting 0 at index 1
l.insert(0,1)
print(l)
# Output : [9,0,8,7]

10.index() : Returns the lowest index where the element appears.

#list 
l=[2,0,8,2]
# Getting the lowest index of 2
a=l.index(2)
print(a)
# Output : 0

Some Important CLI commands

sanadiqbal — Thu, 02 Feb 2023 05:52:28 +0000

IMPORTANT CLI COMMANDS AND THEIR USES

Some of the most commonly used CLI commands :

more :more command is used to view large text files one page at a time.User can scroll up and down through the text using this command.

Syntax
more [ options] -filename

Options
-m : It limits the line displayed in a single page.
-d : displays user message at right corner.
-s :Squeezes blank line.
+/string_name :To find a given string.
+num: To display contents from a specific line.

more can also be used using pipes:

cat filename | more

tail : tail is used to print the last n lines of the given file.

Syntax
tail -[ number of lines] file_name

tail -10 hpt.txt

rsync : rsync is used to sync files between two hosts or machines.

Syntax
rsync [ option ] source [ destination ]
Options
-a : Archive mode includes all necessary options like copying file recursively.
-v : Gives a brief information about files being transferred and the gives brief summary of data transferred at the end.
-h : Outputs in a human readable format.
-z : Compresses file data during transfer.

grep: grep is used to search the file for a particular string.

Syntax
grep [ option ] string_to_be searched filename
Some of the options
-c : prints the count of lines matching the given string
-h : Displays the matched lines only not the file name.
-i :Ignores the cases
-l :Displays file name list only
-n :Display the matched lines and their number.
-v :Prints all the line that don't match the given string.

grep -c ball a.txt

find: find command is used to find files and directories. Syntax find [ where to find ] [ options ] [ what to find]

Options
-name : Searches the file for a given name.
-user : Search the file with given user name.
-perm : Searches the file for a given file permission.

find ~ -name abc.txt

We can also use wild card characters if we only know the partial file name.* is used to for more than one character.

Example:

find . -name  *java*