Given the requirements and the limitations of our interaction (as I cannot actually draw an EER diagram or execute SQL statements), I can provide a textual description of how this project could be approached in each phase:

1. Conceptual Design Phase:

To create the EER diagram, you need to entities, their attributes, and relationships. Here is how you can conceptualize it:

Entities and Their Attributes:

• Course: {Course No (PK), Title,, Level, Subject}
• Instructor: {Instructor ID (PK), Name, Mobile Phone, Email, Street, City, Country, Specialty, Employment Status}
• Training: {Period ID (PK), Start Date, End Date}
• Student: {Student ID (PK), Student Number, Name, Street Name, City, Country,, Age}

Relationships:

• An Instructor "conducts" Course, which is a many-to-many relationship since a Course can be instructed by multiple Instructors and an Instructor can conduct multiple Courses.
• A Course "is taught during" a Training Period, implying a many-to-many relationship as well.
• A Student "takes" a Course during a Training Period, which is another many-to-many relationship.

Assumptions:

• The "specialty" an Instructor applies to a single subject.
• Part-time and full-time employment statuses are mutually exclusive.
• Part-time Instructors an additional attribute for Hours Worked Monthly and Pay Rate.

2. Logical Design Phase:

Mapping the EER into relations and ensuring minimal nulls with primary and foreign keys:

Tables (Primary keys are underlined and foreign keys are asterisks):

• Course (Course_No, Title, Units, Level, Subject)
• Instructor (structor_ID, Name, Mobile_Phone, Email, Street_Name, City, Country, Specialty, Employment_Status, Monthly_Salary, Hours_Worked, Pay_Rate- Training_Period (Period_ID, Start_Date, End_Date)
• (Student_ID, Student_Number, Name, Street_Name, City, Country, Email, Age)
• Courseffering (Course_No*, Period_ID*, Instructor_ID*)
• Student_Enrollment (Student_ID*, Course_No*, Period_ID*)

Notes:

• Course_Offering and Student_rollment are junction tables to handle many-to-many relationships.
• Full-time instructors will have a non-null Monthly_Salary and null values for Hours_Worked and Pay_Rate.
• Part-time instructors will have non-null values for Hours_Worked and Pay_Rate, with a null value for Monthly_Salary.

3. Relations Normalization Phase:

To normalize the tables to 3NF:

• All tables are already in 1NF because they have a primary key, and all attributes are atomic.
• They are in 2NF because there is no partial of any column on the primary key (all non-key attributes are fully functionally dependent on the primary key).
• To achieve 3NF, we need to ensure that no transitive dependencies exist. If necessary, the Instructor table might be split if there are attributes depending on the Employment_Status, but this is not indicated here.

4. Database Implementation Phase:

Creating tables using SQL (DDL):

CREATE TABLE Course (
 _No INT PRIMARY KEY,
  Title VARCHAR(255),
  Units INT,
  VARCHAR(255),
  Subject VARCHAR(255)
);

CREATE TABLE Instructor (
  Instructor_ID INT PRIMARY KEY,
  Name VARCHAR(255),
  Mobile_Phone VARCHAR(20),
  Email VARCHAR(255),
 Street_Name VARCHAR(255),
  City VARCHAR(255),
  VARCHAR(255),
  Specialty VARCHAR(255),
  Employment_Status VARCHAR(50),
  Monthly_Salary DECIMAL(10, 2),
  Hours_Worked INT,
 Pay_Rate DECIMAL(10, 2)
);

CREATE TABLE Training_Period (
  Period_ID INT PRIMARY KEY,
  Start_Date,
  End_Date DATE
);

CREATE TABLE Student (
  Student INT PRIMARY KEY,
  Student_Number VARCHAR(255),
  Name VARCHAR(255),
  Street_Name VARCHAR255),
  City VARCHAR(255),
  Country VARCHAR(255  Email VARCHAR(255),
  Age INT
);

-- Assuming a composite key here for the junction tables.
CREATE TABLE Course_Offering (
  Course_No INT,
 Period_ID INT,
  Instructor_ID INT,
  PRIMARY KEY (_No, Period_ID),
  FOREIGN KEY (Course_No) REFERENCES Course(Course_No),
  FOREIGN KEY (Period_ID) REFERENCES Training_PeriodPeriod_ID),
  FOREIGN KEY (Instructor_ID) REFERENCES Instructor(Instructor_ID)
);

CREATE TABLE Student_Enrollment (
  Student_ID INT,
  Course_No INT,
  Period_ID INT,
 PRIMARY KEY (Student_ID, Course_No, Period_ID),
  FOREIGN KEY (Student_ID) REFERENCES Student_ID),
  FOREIGN KEY (Course_No) REFERENCES Course(Course_No),
  FOREIGN KEY (  

Phase 1: Conceptual Design Phase

Assumptions:

• Each has a unique identifier, but instructors with similar names can be differentiated by their mobile phone, street, or email.
• Full-time instructors have a set monthly salary, and if they take on extra courses, there's a system to compensate them similarly to part-time instructors.
• A course has unique identifiers but can have several instances per training period, each potentially taught by different instructors.
• A student's ID is unique, and the student number be a less permanent identifier (like an enrollment number for a particular period).
• A training period is unique yearly, meaning there cannot be overlapping periods.

EER Diagram (Descriptive):

1. Course

   • Attributes: Course No (PK), Title, Units, Level, Subject

2. **Instructor - Attributes: Instructor ID (PK), Name, Mobile Phone, Email, Street, City Country, Specialty, Employment Status (Which can determine if Monthly Salary or Hours Worked and Pay Rate attributes should be filled)

3. Training Period

   • Attributes: Period ID (PK), Start Date, End Date

4. ---

   • Attributes: Student ID (PK), Student Number, First Name, Name, Street Name, City, Country, Email, Age

5. Relationships:

   • conducts Course (M:N)
   • Course is taught during Period (M:N)
   • Student participates in Course during Training Period (M, Maximum 3 per Training Period)

In UML notation, entities would be as rectangles, relationships as diamonds, and PK as underlined attributes.

Phase 2: Logical Design Phase

Relations:

1. Course

   • Course_No (PK), Title, Units, Level, Subject

2. Instructor -_ID (PK), Name, Mobile_Phone, Email, Street, City, Country, Specialty, Employment_Status

   • For Employment_Status:
     • Full_Time (Instructor_IDFK), Monthly_Salary)
     • Part_Time (Instructor_ID (FK), Hours_Worked,_Rate)

3. Training_Period

   • Period_ID (PK), Start_Date End_Date

4. Student

   • Student_ID (PK),_Number, Name, Street, City, Country, Email, Age

5. Course_Instructor

   • Course_No (FK),_ID (FK), Period_ID (FK) - Composite Key

6. Studentourse

   • Student_ID (FK), Course_No (FK), Period_ID (FK) - Composite Key unless detail on enrollments is needed

Foreign Keys (FK) are marked and reference the Primary Key (PK) of their respective related table.

Phase 3: Relations Normalization Phase

All relations are normalized to 3NF:

• All are in 1NF (no repeating groups, all tables have a primary key).
• All are in 2 (no partial dependencies on the primary key; all non-key columns are dependent on the whole of a composite primary key).
• All are in 3NF (no transitive; all non-key columns are directly dependent on the primary key only).

Phase 4: Database Implementation Phase

Sample SQL DDL:

-- tables
CREATE TABLE Instructors (
  Instructor_ID INT PRIMARY KEY,
  -- Other attributes
);

-- Similar CREATE TABLE statements for Course, Student, Training_Period

-- Note: The Course_Instructor and Student_Course are
-- junction tables to resolve many-to-many relationships.
CREATE TABLE Coursestructor (
  Course_No INT,
  Instructor_ID INT,
  Period_ID,
  PRIMARY KEY (Course_No, Instructor_ID, Period_ID),
  FOREIGN KEYCourse_No) REFERENCES Course(Course_No),
  FOREIGN KEY (Instructor_ID) REFERENCES Instructors(Instructor_ID),
  FOREIGN KEY (Period_ID) REFERENCES Training_Period(_ID)
);

CREATE TABLE Student_Course (
  Student_ID INT,
  Course_No INT,
  Period_ID INT,
  PRIMARY KEY (Student_ID, Course_No, Period_ID),
 FOREIGN KEY (Student_ID) REFERENCES Student(Student_ID),
  FOREIGN KEY (Course_No) REFERENCES Course(Course_No),
  FOREIGN KEY (Period_ID) REFERENCES Training_Period(_ID)
);

-- Insert sample data
-- INSERT INTO statements for each table with sample data goes here

SQL Query:

-- List instructors who are full time and worked on a part-time basis, in alphabetical order
SELECT Name
FROM Instructors
WHERE Employment_Status = 'Full time' AND Instructor_ID IN (
  SELECT Instructor_ID
  FROM Course_Instructor
  WHERE Instructor_ID IN (
      SELECT Instructor_ID
      FROM Part_Time
  )
)
ORDER Name;

-- List all