DEV Community: Vera-778

Class Inheritance

Vera-778 — Mon, 25 Mar 2024 07:47:10 +0000

class Person:
    def __init__(self, first_name, last_name):
        self.first_name = first_name
        self.last_name = last_name
    def full_name(self):
        return self.first_name + ' ' + self.last_name
    def reverse_name(self):
        return self.last_name + ', ' + self.first_name

class Employee(Person): # Add Person to Employee in brackets, to make it a subclass of Person
    role = None
    def full_name_with_role(self): #add special attributes to the child class, in addition to the attributes get from parent class.
        return self.first_name + ' ' + self.last_name + ', ' + self.role
    def reverse_name(self): #override in child class
        return self.role + ', ' + self.first_name

x = Employee('John', 'Smith')
x.role = 'Director'
print(x.full_name_with_role())
print(x.reverse_name())

Attributes can be instance

Vera-778 — Mon, 25 Mar 2024 02:33:02 +0000

An attribute of an object can be an instance of another class, or perhaps even the same class.

basil = Person('Basil', 'Fawlty') #basil is an instance here
polly = Person('Polly', 'Sherman', basil) # basil is an attribute of boss of polly here
print(polly.boss.full_name()) #Basil Fawlty

class Person:
    def __init__(self, first_name, last_name, boss = None):
        self.first_name = first_name
        self.last_name = last_name
        self.boss = boss
    def full_name(self):
        return self.first_name + ' ' + self.last_name
    def reverse_name(self):
        return self.last_name + ', ' + self.first_name

Instance Attributes & Class Attributes

Vera-778 — Mon, 25 Mar 2024 02:17:49 +0000

class Square:
    def __init__(self, side):
        self.side = side
    def area(self): # self parameter - this is an instance method
        return self.side ** 2
    def calculate_area(side): # No self parameter - this is a class method 
        return side ** 2

sq = Square(10) # Create an instance
print(sq.area()) # Invoke an instance method
print(Square.calculate_area(20)) # Invoke a class method

The method can be invoked by using the class name and the method name. It provides a way of organising methods that are related to the class, but do not belong on the instances themselves.

If the attribute is a field then you can make it a class field by defining it outside the constructor. It will be then shared by all class instances. it represents a characteristic of the entire class rather than individual objects. Class fields have a single value shared by all instances. Hence changing the value impacts all instances equally as shown in the example below:

class Square:
    nbInstances = 0
    def __init__(self, side):
        self.side = side
        Square.nbInstances += 1
    def area(self): # self parameter - this is an instance method
        return self.side ** 2
    def calculate_area(side): # No self parameter - this is a class method 
        return side ** 2

sq = Square(10) # Create an instance
print(sq.area()) # Invoke an instance method
print(Square.calculate_area(20)) # Invoke a class method
print(Square.nbInstances) # Outputs 1
print(sq.nbInstances) # Outputs 1
sq2 = Square(10) # Create another instance
print(Square.nbInstances) # Outputs 2
print(sq.nbInstances) # Outputs 2

Some Special Methods in Python Class

Vera-778 — Mon, 25 Mar 2024 01:59:24 +0000

class Square:
def init(self, side):
self.side = side
def eq(self, other):
return self.side == other.side
def ne(self, other):
return self.side != other.side

def lt(self, other):
return self.side < other.side
def le(self, other):
return self.side <= other.side
def gt(self, other):
return self.side > other.side
def ge(self, other):
return self.side >= other.side

sq1 = Square(10)
sq2 = Square(11)
print(sq1 != sq2)
print(sq1 < sq2)
print(sq1 <= sq2)
print(sq1 > sq2)
print(sq1 >= sq2)

+: object.add(self, other)
-: object.sub(self, other)
: object.mul(self, other)
/: object.div(self, other)
%: object.mod(self, other)
*: object.pow(self, other)
&: object.and(self, other)
^: object.xor(self, other)
|: object.or(self, other)
+=: object.iadd(self, other) ("i" for in place)
-=: object.isub(self, other)
=: object.imul(self, other)
/=: object.idiv(self, other)
%=: object.imod(self, other)
*=: object.ipow(self, other)
-: object.neg(self)
+: object.pos(self)
abs(): object.abs(self)
int(): object.int(self)
float(): object.float(self)

Date and Time in Python

Vera-778 — Tue, 20 Feb 2024 03:53:09 +0000

When working with real-world data you often have to deal with dates and times. Date and times can be tricky to work with, because people format and present them in different ways. Consider, for example, a date written as "02-03-1998". Does this represent 2nd March 1998, or 3rd February 1998? In Australia it would be the former, but in the US it would be the latter.

Python has a datetime library that defines datetime , date, and time types. These provide a uniform and comprehensive way to handle dates and times. The datetime type is the most flexible and thus the most commonly used. There is also a timedelta type, which is used to work with durations (i.e., time intervals).

To use these you need to import them:

from datetime import datetime, date, time, timedelta

You don't need to import them all - just the ones you will be using.

Usually your goal will be to convert a string or integer representation of a date or time into a datetime object, apply whatever processing you need to the object, and then use a formatting function to convert it back to a traditional format.

Creating a datetime object
There are several ways to create a datetime object.

You can directly construct it by providing the year, month, and day, and, optionally, the time and timezone.

from datetime import datetime dt = datetime( year = 1968, month = 6, day = 24, hour = 5, minute = 30, second = 0 ) print(dt)

You can also construct it from a string. In this case you need to tell Python what format the string uses:

from datetime import datetime dt = datetime.strptime('24-06-1968, 05:30:00', '%d-%m-%Y, %H:%M:%S') print(dt)

The trickiest part about this is remembering what the formatting codes are. You'll probably find yourself looking them up quite often. Here are the main ones:

%Y Four-digit year (1968)
%y Two-digit year (68)

%B Full month name (June)
%b Abbreviated month name (Jun)
%m Two-digit month number (01-12)

%A Full day name (Monday)
%a Abbreviated day name (Mon)
%d Two-digit day number (01-31)

%H Two-digit hour (00-23)
%I Two-digit hour (00-12)

%M Two-digit minute (00-59)
%S Two-digit second (00-59)

%p AM/PM

If you want a datetime object that represents the current date and time you can use the now method:

from datetime import datetime dt = datetime.now() print(dt)

Unix timestamp
You can also construct a datetime object from a Unix timestamp. This is one of the most common representations of time. It represents the time as a numerical value - the number of seconds since the Unix epoch, which was at 00:00:00 on Thursday, 1 January 1970 UTC. You can get the current Unix timestamp using the time.time function.

from time import time print(time())

To create a datetime object from a Unix timestamp you can use use datetime.fromtimestamp().

from datetime import datetime x = datetime.fromtimestamp(1565315907) print(x)

Extracting the components of a datetime object
Once you have a datetime object you can extract its individual components:

from datetime import datetime dt = datetime( year = 1968, month = 6, day = 24, hour = 5, minute = 30, second = 0 ) print(dt.year) print(dt.month) print(dt.day) print(dt.hour) print(dt.minute)

You can also extract a date object or a time object from a datetime object:

from datetime import datetime dt = datetime( year = 1968, month = 6, day = 24, hour = 5, minute = 30, second = 0 ) print(dt.date()) print(dt.time())

Formatting a datetime object as a string
A very common thing to do is to present a datetime object in a certain format. You can use the strftime method, to do this. You need to specify the format you would like, using the same formatting codes as listed above.

from datetime import datetime dt = datetime( year = 1968, month = 6, day = 24, hour = 5, minute = 30, second = 0 ) print(dt.strftime('%d %B %Y, at %I:%M %p'))

Operating on datetime objects
One of the most useful features of datetime objects is that you can very easily calculate new dates and times. The datetime module is so nicely designed that the following examples should be self-explanatory:

First example:

from datetime import datetime, timedelta now = datetime.now() print(now + timedelta(hours=1)) print(now + timedelta(days=1)) print(now - timedelta(weeks=2)) print(now + timedelta(weeks=4, days=3, hours=2, seconds=45))

Second example:

from datetime import datetime, timedelta new_years_eve = datetime(year=2024, month=12, day=31) now = datetime.now() time_remaining = new_years_eve - now print(time_remaining)

The Past, Present, and Future of Database Technology

Vera-778 — Tue, 13 Feb 2024 07:23:36 +0000

Past:

Relational Databases (1970s - 1990s):
- The past of database technology is characterized by the dominance of relational databases. Pioneered by Edgar F. Codd in the 1970s, relational databases, such as IBM's DB2, Oracle, and Microsoft SQL Server, became the standard for managing structured data. SQL (Structured Query Language) emerged as the standard language for interacting with relational databases.
Client-Server Architecture:
- In the 1980s and 1990s, client-server architectures became prevalent. Database servers served as centralized repositories for data, and client applications interacted with these servers to retrieve and manipulate data. This architecture improved scalability and allowed for distributed computing.
Normalization and Data Integrity:
- The emphasis on normalization techniques to reduce redundancy and improve data integrity became a fundamental principle in database design during this period. Database management systems (DBMS) focused on enforcing data integrity through constraints and normalization rules.

Present:

Big Data and NoSQL (2000s - Present):
- The present era has seen the emergence of big data technologies and NoSQL databases. With the rise of web applications and the need to handle large volumes of unstructured or semi-structured data, NoSQL databases like MongoDB, Cassandra, and Couchbase gained popularity. These databases provide flexibility and scalability for handling diverse data types and large datasets.
Cloud-Based Databases:
- Cloud computing has significantly influenced database technology. Cloud-based databases, offered by providers like Amazon Web Services (AWS), Microsoft Azure, and Google Cloud Platform, enable organizations to scale their database infrastructure dynamically, pay for usage, and leverage managed services for database administration.
Polyglot Persistence:
- The concept of polyglot persistence acknowledges that different types of data are best suited for different database models. Organizations often use a mix of relational and NoSQL databases based on the nature of their data and specific use cases.
In-Memory Databases:
- In-memory databases, such as SAP HANA and Redis, have gained popularity for their ability to store and retrieve data directly from RAM, leading to significant performance improvements. This is particularly valuable for applications requiring low-latency access to data.

Future:

Machine Learning and AI Integration:
- The future of database technology is likely to involve tighter integration with machine learning and artificial intelligence. Databases may incorporate AI-driven features for query optimization, data analysis, and automated decision-making processes.
Blockchain and Distributed Ledgers:
- Blockchain technology and distributed ledger systems are gaining attention for their potential impact on databases. These technologies offer decentralized, secure, and tamper-proof methods for recording and verifying transactions, which could have implications for data integrity and trust.
Serverless Databases:
- Serverless database architectures, where infrastructure management is abstracted away, are becoming more prevalent. Serverless databases can automatically scale based on demand, offering cost-efficiency and simplicity for developers.
Graph Databases:
- Graph databases, designed to handle relationships efficiently, are expected to play a more significant role, especially in applications involving social networks, fraud detection, and recommendation systems.
Continued Evolution of NoSQL:
- The NoSQL landscape will likely continue to evolve, with new databases emerging to address specific use cases and challenges. Features such as multi-model databases, combining graph, document, and key-value stores, may become more common.
Edge Databases:
- With the growth of edge computing, databases optimized for edge environments, where data is processed closer to the source, may become more prevalent. These databases will address the challenges of latency and connectivity in distributed and edge computing scenarios.

Transactions and Concurrency Control

Vera-778 — Tue, 13 Feb 2024 07:02:13 +0000

Transactions:

A transaction is a sequence of one or more operations on a database that is executed as a single unit of work. The primary goal of transactions is to maintain the consistency and integrity of the database even in the presence of failures. Transactions adhere to the ACID properties:

Atomicity:
- Atomicity ensures that a transaction is treated as a single, indivisible unit of work. Either all the changes made by the transaction are committed to the database, or none of them are. If any part of the transaction fails, the entire transaction is rolled back.
Consistency:
- Consistency ensures that a transaction brings the database from one valid state to another. The database should always be in a consistent state, meaning it adheres to the defined integrity constraints and business rules.
Isolation:
- Isolation ensures that the execution of one transaction is isolated from the execution of other transactions. Even if multiple transactions are executed concurrently, each should see the database as if it is the only transaction in progress. Isolation levels (e.g., Read Uncommitted, Read Committed, Repeatable Read, Serializable) define the degree of isolation.
Durability:
- Durability guarantees that once a transaction is committed, its effects will persist even in the face of system failures. The changes made by committed transactions are permanently stored in the database.

Concurrency Control:

Concurrency control is a mechanism used to manage the simultaneous execution of multiple transactions in a way that maintains the consistency of the database. It addresses issues that can arise when multiple transactions are executed concurrently, such as lost updates, uncommitted data, and inconsistent reads. Key concepts and techniques in concurrency control include:

Locking:
- Locking is a common technique used to control access to data. Transactions acquire locks on data items, preventing other transactions from accessing or modifying the same data simultaneously. There are different types of locks, such as read locks and write locks.
Isolation Levels:
- Isolation levels define the degree to which one transaction is isolated from the effects of other concurrently executing transactions. Common isolation levels include Read Uncommitted, Read Committed, Repeatable Read, and Serializable. Higher isolation levels provide stronger guarantees but may lead to more contention.
Serializability:
- Serializability ensures that the execution of a set of concurrent transactions is equivalent to some serial execution of those transactions. In other words, the final result is as if transactions were executed one after another, even though they may execute concurrently.
Timestamp Ordering:
- Timestamp ordering uses timestamps to order transactions and their operations. Transactions are assigned timestamps, and the system ensures that transactions are executed in timestamp order. This helps maintain a consistent and predictable order of transactions.
Two-Phase Locking (2PL):
- Two-Phase Locking is a concurrency control protocol that ensures transactions follow a set of rules regarding acquiring and releasing locks. The protocol has two phases: the growing phase, where locks can be acquired, and the shrinking phase, where locks can only be released.
Optimistic Concurrency Control:
- Optimistic Concurrency Control assumes that conflicts between transactions are rare. Instead of locking data, it allows transactions to proceed without interference and checks for conflicts only at the end of the transaction. If conflicts are detected, appropriate actions are taken.
Multiversion Concurrency Control (MVCC):
- MVCC maintains multiple versions of a data item to allow concurrent transactions to read and modify the data without blocking each other. Each transaction sees a snapshot of the database at a specific point in time.

Concurrency control is crucial in a multi-user database environment where multiple transactions may try to access and modify data simultaneously. By ensuring that transactions are executed in a controlled manner, concurrency control mechanisms help prevent data inconsistencies and maintain the integrity of the database.

Why Study Databases

Vera-778 — Tue, 13 Feb 2024 03:08:35 +0000

1.Databases touch all aspects of our lives.

Data will always have to be: stored, manipulated/accessed, shared, and transmitted. We can define database as a collection of related data that models some aspect of the real world. Also, databases are the core component of most computer applications.

2.Using file systems as data management has draw backs. Database systems offer solutions.

Data redundancy and inconsistency. There might be dupliction of information in different files. And the files would have multiple formats.
Difficulty in accessing data. There is always a new program needed to carry out a new task.
Integrity problems. Intergrity constraints might be unnoticed, while in databases, they'll be clearly kept and stated. Also, it's hard to add/mordify constraints in file system. (need to be understanded by practise)
Data isolation. Which is obvious.
Atomicity of updates. Not quiet understand.
Hard to allow concurrent access by multiple users. Uncontrolled concurrent accesses can lead to inconsistencies.

3.The field of databases deals with data, relationships, constraints, redundancy, data manipulation, transactions, concurrency, and scale. I'll find out exactly what they mean later.

4.About Data

According to Elmasri/Navathe, data are known facts that can be recorded. There are two types of Data, one is unstructured, the other is structured.

5.About Database

Database is a collection of related and structured data. Data items alone are relatively useless.

Database Management

DBMS(Database Management System): Which manipulate and maintain databases.
Database system: Database + DBMS.

Database Users

DBAs(Database Administrator), Application Programmers, and End Users.

Design a Database

Conceptual Design: Requirements can be represented and manipulated using some computerized tools so that it can be easily maintained, modified, and transformed into a database implementation.
Logical Design: Translated by conceptual design that can be expressed in a data model implemented in a DBMS.
Physical Design: Further specifications are provided for storing and accessing the database.

6.RDBMS(Relational DBMS)

Data Model

Definition: concepts used to describe the allowed structure of a database.
Levels of DM: High-level or conceptual (ER model for example), implementation or record-based, andd low-level or physical.
Database Schema: a formalism of the data model, the structual description of what information will database hold.
Database instance: any conbination of actual information populated in the database at a particular time.

How to use stored procedures and triggers to extend DBMS capabilities

Vera-778 — Sun, 11 Feb 2024 03:14:13 +0000

Stored procedures and triggers are database objects that can be used to extend the capabilities of a Database Management System (DBMS). They provide a way to encapsulate business logic, automate tasks, and enforce data integrity.

Stored Procedures:

Create a Stored Procedure:
- Use the CREATE PROCEDURE statement to define a stored procedure. It can include input parameters, output parameters, and a set of SQL statements.

   DELIMITER //
   CREATE PROCEDURE sp_example(IN parameter1 INT, OUT result1 INT)
   BEGIN
       -- SQL statements
   END //
   DELIMITER ;

Call a Stored Procedure:
- Use the CALL statement to execute a stored procedure.

   CALL sp_example(1, @output);

Input and Output Parameters:
- Define input parameters using IN and output parameters using OUT. Parameters allow you to pass values into and out of the stored procedure.

Triggers:

Create a Trigger:
- Use the CREATE TRIGGER statement to define a trigger. A trigger is associated with a specific table and is executed automatically when a specific event (e.g., INSERT, UPDATE, DELETE) occurs on that table.

   DELIMITER //
   CREATE TRIGGER tr_example
   AFTER INSERT ON table_name
   FOR EACH ROW
   BEGIN
       -- SQL statements
   END //
   DELIMITER ;

Trigger Events:
- Specify the trigger event (INSERT, UPDATE, DELETE) and the timing (BEFORE or AFTER) using the BEFORE or AFTER keywords.
Accessing Old and New Values:
- Use OLD and NEW to reference the old and new values in the trigger body. This is especially useful in UPDATE triggers.

   CREATE TRIGGER tr_example
   BEFORE UPDATE ON table_name
   FOR EACH ROW
   BEGIN
       -- Access old and new values
       SET @old_value = OLD.column_name;
       SET @new_value = NEW.column_name;
   END;

Enforce Data Integrity:
- Triggers can be used to enforce data integrity by performing additional checks or actions when certain conditions are met.

   CREATE TRIGGER tr_check_balance
   BEFORE INSERT ON transactions
   FOR EACH ROW
   BEGIN
       IF NEW.amount > @account_balance THEN
           SIGNAL SQLSTATE '45000'
           SET MESSAGE_TEXT = 'Insufficient funds';
       END IF;
   END;

Drop a Trigger:
- Use the DROP TRIGGER statement to remove a trigger from the database.

   DROP TRIGGER IF EXISTS tr_example;

Fundamental SQL concepts

Vera-778 — Sun, 11 Feb 2024 02:50:29 +0000

Hi guys, this is the first day I learn IT (officially). I decide to take notes about whatever I think important and related. Hopefully I can form a network of knowledge one day.
It would be so ideal if someone read my posts and help me improve. All suggestions are welcomed. Learning is detemined to be a road of loneliness, but one will go further with other lonely geeks. That's what I thought the meaning of communities.

1. SELECT Statement:

The SELECT statement is used to retrieve data from one or more tables.

   SELECT column1, column2
   FROM table_name;

2. FROM Clause:

The FROM clause specifies the table or tables from which to retrieve data.

   SELECT column1, column2
   FROM employees;

3. WHERE Clause:

The WHERE clause is used to filter rows based on specific conditions.

   SELECT column1, column2
   FROM table_name
   WHERE condition;

4. AND, OR, NOT Operators:

Combine conditions using AND, OR, and NOT operators in the WHERE clause.

   SELECT column1, column2
   FROM table_name
   WHERE condition1 AND condition2;

5. ORDER BY Clause:

The ORDER BY clause is used to sort the result set based on one or more columns.

   SELECT column1, column2
   FROM table_name
   ORDER BY column1 ASC;

6. INSERT INTO Statement:

The INSERT INTO statement is used to insert new records into a table.

   INSERT INTO table_name (column1, column2)
   VALUES (value1, value2);

7. UPDATE Statement:

The UPDATE statement is used to modify existing records in a table.

   UPDATE table_name
   SET column1 = value1, column2 = value2
   WHERE condition;

8. DELETE Statement:

The DELETE statement is used to remove records from a table.

   DELETE FROM table_name
   WHERE condition;

9. JOIN Clause:

The JOIN clause is used to combine rows from two or more tables based on a related column.

   SELECT column1, column2
   FROM table1
   INNER JOIN table2 ON table1.column = table2.column;

10. GROUP BY Clause:

- The `GROUP BY` clause is used to group rows based on one or more columns, often used with aggregate functions.

```sql
SELECT column1, COUNT(*)
FROM table_name
GROUP BY column1;
```

11. HAVING Clause:

- The `HAVING` clause is used with the `GROUP BY` clause to filter the results based on aggregate values.

```sql
SELECT column1, COUNT(*)
FROM table_name
GROUP BY column1
HAVING COUNT(*) > 10;
```

12. Aliases:

- Use aliases to provide temporary names for columns or tables in your queries.

```sql
SELECT column1 AS alias1, column2 AS alias2
FROM table_name;
```

13. Comments:

- Use `--` for single-line comments or `/* */` for multi-line comments.

```sql
-- This is a single-line comment

/*
This is a
multi-line comment
*/
```