From 065dd49e21cdc81f535d50bb57445b118cb3abfb Mon Sep 17 00:00:00 2001
From: bmcabrera <124897769+bmcabrera@users.noreply.github.com>
Date: Thu, 28 Sep 2023 11:04:22 -0400
Subject: [PATCH] first updates (#25)

---
 learnEcl/1400-filter.md    | 182 +++++++++++++++++++
 learnEcl/2200-sample.md    |  66 +++++++
 learnEcl/2500-transform.md | 193 +++++++++++++++++++++
 learnEcl/2600-project.md   |  96 ++++++++++
 learnEcl/2700-function.md  | 144 +++++++++++++++
 learnEcl/2800-module.md    | 117 +++++++++++++
 learnEcl/3000-join.md      | 346 +++++++++++++++++++++++++++++++++++++
 learnEcl/3100-table.md     | 233 +++++++++++++++++++++++++
 learnEcl/3200-normalize.md | 211 ++++++++++++++++++++++
 9 files changed, 1588 insertions(+)

diff --git a/learnEcl/1400-filter.md b/learnEcl/1400-filter.md
index 0168777..5128918 100644
--- a/learnEcl/1400-filter.md
+++ b/learnEcl/1400-filter.md
@@ -2,3 +2,185 @@
 title: Filter
 slug: filter
 ---
+
+# FILTER
+
+Data filtering is the process of choosing a smaller part of your data set and using that subset for further processing. It’s recommended to filter down to the desire dataset before any processing. When using filter on STRING values keep in mind that STRING values are case sensitive. For example Sun, sun, SUN are not the same.
+
+## SQL vs. ECL
+
+Filter is similar to SELECT. In ECL the filtering fields are in ( ).
+<pre>
+<EclCode code="// SQL 
+SELECT name, address FROM PeopleDS WHERE name = 'Jo';
+
+// ECL
+OUTPUT(peopleDS(name = 'Jo'));">
+</EclCode>
+</pre>
+
+## Syntax
+
+<pre>
+<EclCode code="attr_name := dataset_name (filtering condition(s));">
+</EclCode>
+</pre>
+
+| _Value_ | _Definition_ |
+| :- | :- |
+| attr_name | The name by which the function will be invoked. |
+| dataset_name | The dataset to perform action on. |
+| Filtering condition(s) | Field or fields and required filtering conditions. Logical operators can be used to execute multiple filters. |
+
+### Demo Dataset
+
+| PersonID | FirstName | LastName | isEmployed | avgHouseIncome |
+| :- | :- | :- | :- | :- |
+| 102 | Fred | Smith | FALSE | 0 |
+| 012 | Joe | Blow | TRUE | 11250 |
+| 085 | Blue | Moon | TRUE | 185000 |
+| 055 | Silver | Jo | FALSE | 5000 |
+| 265 | Darling | Jo | TRUE | 5000 |
+| 333 | Jane | Smith | FALSE | 50000 |
+
+**Example**
+
+<pre>
+<EclCode
+id="FilterExp_1"
+tryMe="FilterExp_1"
+code="/*Filter Example:*/
+
+/*
+FILTER Example:
+Showing different examples of FILTER function 
+based on different fields or logical operator.
+*/
+
+// Creating record layout
+Emp_layout := RECORD
+    INTEGER  PersonID; 
+    STRING   FirstName; 
+    STRING   LastName; 
+    BOOLEAN  IsEmp;
+    INTEGER  RoundedIncome;
+END; 
+
+// Creating an inline dataset
+Emp_DS := DATASET([
+                {102,'Fred','Smith',FALSE,0},
+                {012,'Joe','Blow',TRUE,11250},
+                {085,'Blue','Moon',TRUE,185000},
+                {055,'Silver','Jo',FALSE,5000},
+                {265,'Darling','Jo',TRUE,5000},
+                {333,'Jane','Smith',FALSE,50000}],
+                Emp_layout);
+
+// Filter Smith last name
+GetSmith := Emp_DS(LastName='Smith');
+OUTPUT(GetSmith, NAMED('GetSmith'));
+
+// Notice that following filter will return an empty dataset
+OUTPUT(Emp_DS(LastName='smith'), NAMED('Case_Sensitive'));
+
+
+// Filter unemployed with income using logical operators
+IsWorking := Emp_DS(IsEmp = FALSE AND
+                    RoundedIncome > 0);
+
+OUTPUT(IsWorking, NAMED('IsWorking'));
+
+// Capturing everyone that is employed 
+// Following filter is the same as: 
+// Emp_DS(IsEmp = TRUE)
+OUTPUT(Emp_DS(IsEmp), NAMED('Employed'));
+
+"></EclCode>
+</pre>
+
+## Logical Operators
+
+| Operator | Description |
+| :- | :- |
+| = | Equal |
+| > | Greater than |
+| &lt; | Something |
+| >= | Greater than or equal |
+| &lt;= | Less than or equal |
+| &lt;> | Not equal |
+| != | Not equal |
+| AND | Logical AND |
+| OR | Logical OR |
+| IN | To specify multiple possible values for a field/column. |
+| NOT IN | To specify multiple possible values that are not in a field/column. |
+| BETWEEN | Between a certain range. |
+
+**Example**
+
+<pre>
+<EclCode
+id="FilterExp_2"
+tryMe="FilterExp_2"
+code="/*
+Filter Example
+*/
+
+StrokeRec := RECORD
+    STRING   ID;	
+    STRING   Gender;	
+    INTEGER  Age;	
+    BOOLEAN  Hypertension;	
+    BOOLEAN  Heart_Disease;	
+    STRING   Ever_Married;	
+    STRING   Work_Type;	
+    STRING   Residence_Type;	
+    STRING   Avg_Glucose_Level;	
+    STRING   BMI;	
+    STRING   Smoking_status;	
+    BOOLEAN  Stroke;
+END;
+
+
+StrokeDS := DATASET('~raw::healthcare-dataset-stroke-data.csv', StrokeRec, CSV(HEADING(1)));
+
+// Filtering men over age of 80
+Over80 := StrokeDS(Age >= 80);
+OUTPUT(Over80, NAMED('Over80'));
+
+
+
+"></EclCode>
+</pre>
+
+<pre>
+<EclCode
+id="FilterExp_3"
+tryMe="FilterExp_3"
+code="/*
+Filter Example
+*/
+
+StrokRec := RECORD
+    STRING   ID;	
+    STRING   Gender;	
+    INTEGER  Age;	
+    BOOLEAN  Hypertension;	
+    BOOLEAN  Heart_Disease;	
+    STRING   Ever_Married;	
+    STRING   Work_Type;	
+    STRING   Residence_Type;	
+    STRING   Avg_Glucose_Level;	
+    STRING   BMI;	
+    STRING   Smoking_status;	
+    BOOLEAN  Stroke;
+END;
+
+
+StrokDS := DATASET('~raw::healthcare-dataset-stroke-data.csv', StrokRec, CSV(HEADING(1)));
+
+// Over 80 years old men with heart disease 
+OUTPUT(StrokDS(Gender = 'Male' AND Age >= 80 AND Heart_Disease), NAMED('Males'));
+
+
+"></EclCode>
+</pre>
\ No newline at end of file
diff --git a/learnEcl/2200-sample.md b/learnEcl/2200-sample.md
index d86ba47..5404f19 100644
--- a/learnEcl/2200-sample.md
+++ b/learnEcl/2200-sample.md
@@ -2,3 +2,69 @@
 title: Sample
 slug: sample
 ---
+
+# SAMPLE
+
+SAMPLE function returns a sample set of dataset. Returned value is a dataset.
+
+## Syntax
+
+<pre>
+<EclCode code="SAMPLE(dataset, interval, [, which])">
+</EclCode>
+</pre>
+
+| _Value_ | _Definition_ |
+| :- | :- |
+| dataset | Input dataset to process. |
+| interval | The intervals between records to return. |
+| which | Optional. An integer specifying the ordinal number of the sample set to return. This is used to obtain multiple non-overlapping samples from the same recordset. |
+
+### Demo Dataset
+| Color | ID |
+| :- | :- |
+| Red | 100 |
+| Blue | 102 |
+| Black | 103 |
+| Yellow | 104 |
+| Orange | 105 |
+| White | 106 |
+| Green | 107 |
+| Purple | 108 |
+
+**Example**
+
+<pre>
+<EclCode
+id="SampleExp_1"
+tryMe="SampleExp_1"
+code="/*Sample Example:*/
+
+/*
+REAL Example:
+Collecting different sample sizes from the input dataset.
+*/
+
+Color_Layout := RECORD
+    STRING   Color;
+    INTEGER ID;
+END;
+
+Color_DS := DATASET([
+    {'Red', 100},
+    {'Blue', 102},
+    {'Black', 103},
+    {'Yellow', 104},
+    {'Orange', 105},
+    {'White', 106},
+    {'Green', 107},
+    {'Purple', 108}],
+    Color_Layout);
+
+SampleOne := SAMPLE(Color_DS, 3);
+OUTPUT(SampleOne, NAMED('SampleOne'));
+
+SAMPLE(Color_DS, 2, 4);
+
+"></EclCode>
+</pre>
\ No newline at end of file
diff --git a/learnEcl/2500-transform.md b/learnEcl/2500-transform.md
index 1bcf25a..b2233e9 100644
--- a/learnEcl/2500-transform.md
+++ b/learnEcl/2500-transform.md
@@ -2,3 +2,196 @@
 title: Transform
 slug: transform
 ---
+
+# TRANSFORM
+
+TRANSFORM function, defines specific operations that will be performed on every field in result dataset. TRANSFORM functions starts from row one and covers the entire dataset row by row. When defining a transform you need to tell the function what it needs to be done on each field in the result dataset by using input datasets fields or creating new definitions for the fields.
+Transform can be used with PROJECT, JOIN, ITERATE, ROLLUP and more.
+
+## Syntax
+
+<pre>
+<EclCode code="EXPORT [return_dataset_layout] transform_name ([input_arguments_types]+ arg_name ) := TRANSFORM
+      SELF.return_field_name := arg_name.input_dataset_fieldname;
+      SELF := arg_name;
+      SELF := [];
+END;">
+</EclCode>
+</pre>
+
+| _Value_ | _Definition_ |
+| :- | :- |
+| EXPORT | Optional. Used in MODULEs |
+| return_dataset_layout | Record-definition/layout of result dataset. |
+| transform_name | The name by which the transform will be invoked. |
+| input_arguments_types | The argument’s data type. If passing a dataset, the data type is DATASET(record_definition). |
+| arg_name | Used to reference your argument in the transform. |
+| TRANSFORM | Required. |
+| SELF | Reference the field in the return_data_type. |
+| return_field_name | Refers to the field in result dataset. |
+| input_Dataset_fieldname |	Refers to the field in the input dataset. |
+| SELF := [ ] | Assign default value for every field in result dataset that doesn't have a defined operation or doesn't exists in the input dataset. For example if there is a INTEGER field in the result dataset, that transform didn't assign a definition to it, the field will receive a 0 which is the default value for INTEGER. |
+| END | Required. |
+
+## Transform Type One (Standalone TRANSFORM)
+
+If you need the transform to be used in multiple places, or it contains many fields or child datasets, you may want to define a standalone transform (a function that can be called multiple times)
+
+### Demo Dataset
+
+| FirstName | LastName |
+| :- | :- |
+| Sun | Shine |
+| Blue | Moon |
+| Silver | Rose |
+
+**Example**
+
+<pre>
+<EclCode
+id="TransformExp_1"
+tryMe="TransformExp_1"
+code="/*Transform Example:*/
+
+/*
+TRANSFORM Example: 
+Using an input dataset, to concat names and count the number of rows in the input dataset. 
+PROJECT result always have the same number of rows as input dataset. 
+*/
+
+
+// Defining record layout
+Names_layout := RECORD 
+    STRING FirstName;
+    STRING LastName;
+END;
+
+// Creating Explicit dataset
+Names_DS := DATASET([
+              {'Sun','Shine'},
+              {'Blue','Moon'},
+              {'Silver','Rose'}],
+              Names_layout);
+
+// Defining new layout for the project result
+NameOutRec := RECORD
+    STRING  FirstName;
+    STRING  LastName;
+    STRING  CatValues;
+    INTEGER RecCount; //Counter
+END;
+
+/*
+NameOutRec: Result of the project gets saved in this record layout
+CatThem: TRANSFORM name
+Names_layout L: Left datasets that’s passed through project
+INTEGER C: Counter
+*/
+NameOutRec CatThem(Names_layout L, INTEGER C) := TRANSFORM
+
+  // Contacting FirstName with LastName and adding space between them
+  SELF.CatValues := L.FirstName + ' ' + L.LastName; 
+  SELF.RecCount := C; // Counter
+  // Assign default values to all fields that are in result dataset and haven't been define in this TRANSFORM
+  SELF := L; 
+
+END;
+
+/*
+Result: result dataset.
+PROJECT: Required, it can be replaced by other functions.
+Name_DS: Input dataset
+CatThem: TRANSFORM name
+LEFT: Refers to the left dataset. PROJECT always takes one dataset. So, LEFT is the only reference used.
+COUNTER: Counting the number of rows.
+*/
+Result := PROJECT(Names_DS,
+                 CatThem(LEFT, COUNTER));
+
+OUTPUT(Result, NAMED('Result'));
+
+"></EclCode>
+</pre>
+
+## Transform Type Two (Explicit TRANSFORM)
+
+Often times TRANSFORM is small enough to used within PROJECT, JOIN, ROLLUP and other functions. Let's take a look at how it can be used within PROJECT. Similar principal is applied in using transform with other functions mentioned above, at transform definition.
+
+<pre>
+<EclCode code="EXPORT project_name := PROJECT(input_dataset,
+                            TRANSFORM(
+                                return_dataset_layout
+                                SELF.return_field_name := LEFT.input_Dataset_fieldname;
+                                SELF := LEFT;
+                                SELF := RIGHT;
+                                SELF := [];
+                            ));
+">
+</EclCode>
+</pre>
+
+| _Value_ | _Definition_ |
+| :- | :- |
+| EXPORT | Optional, used for constants, or in modules. |
+| project_name | 	The name by which the project will be invoked. |
+| PROJECT | Required. JOIN, ROLLUP and other functions can be used here. |
+| input_dataset | Input dataset itself and not the record definition. |
+| TRANSFORM | Required. |
+| return_dataset_layout | Record-definition/layout of result dataset. |
+| SELF | Reference the field in the return_data_type. |
+| return_field_name | Refers to the field in result dataset. |
+| input_Dataset_fieldname | Refers to the field in the input dataset. |
+| SELF := LEFT | Get the original values from input (left) dataset for all fields that don't have an operation defined. |
+| SELF := RIGHT | Used where there are two input dataset like JOIN. Get the original values from input (right) dataset for all fields that don't have an operation defined. |
+| SELF := [ ] | Assign default value for every field in result dataset that doesn't have a defined operation or doesn't exists in the input dataset. For example if there is a INTEGER field in the result dataset, that transform didn't assign a definition to it, the field will receive a 0 which is the default value for INTEGER. |
+
+**Example**
+
+<pre>
+<EclCode
+id="TransformExp_2"
+tryMe="TransformExp_2"
+code="/*Transform Example:*/
+
+/*
+TRANSFORM Example: 
+Using an input dataset, to concat names and count the number of rows in the input dataset. 
+PROJECT result always have the same number of rows as input dataset. 
+
+This TRANSFORM, PROJECT example provides the exact same result as above example. 
+The only difference is the way TRANSFORM is written and called.
+*/
+
+// Defining record layout
+Names_layout := RECORD 
+    STRING FirstName;
+    STRING LastName;
+END;
+
+// Creating inline dataset
+Names_DS := DATASET([
+              {'Sun','Shine'},
+              {'Blue','Moon'},
+              {'Silver','Rose'}],
+              Names_layout);
+
+// Defining new layout for the project result
+NameOutRec := RECORD
+    STRING  FirstName;
+    STRING  LastName;
+    STRING  CatValues;
+    INTEGER RecCount; //Counter
+END;
+
+ProjResult := PROJECT(Names_DS,
+                    TRANSFORM(NameOutRec,
+                      // Concat FirstName and LastName
+                      SELF.CatValues := LEFT.FirstName + ' ' + LEFT.LastName; 
+                      SELF.RecCount := COUNTER; // Counter
+                      SELF := LEFT // Assign everything from left recordset
+                    ));
+
+OUTPUT(ProjResult, NAMED('ProjResult'));
+
+"></EclCode>
+</pre>
\ No newline at end of file
diff --git a/learnEcl/2600-project.md b/learnEcl/2600-project.md
index 0b1bdd7..e7e6405 100644
--- a/learnEcl/2600-project.md
+++ b/learnEcl/2600-project.md
@@ -2,3 +2,99 @@
 title: Project
 slug: project
 ---
+
+# PROJECT
+
+The PROJECT function processes through all records in the record-set performing the TRANSFORM function on each record in turn. PROJECT result always have the same number of rows as input dataset.
+
+PROJECT is like SQL's SELECT … INTO TABLE …
+
+## Syntax
+
+<pre>
+<EclCode code="// Explicit TRANSFORM
+EXPORT project_name := PROJECT(input_dataset,
+                            TRANSFORM(
+                                SELF.return_field_name := LEFT.input_Dataset_fieldname;
+                                ...
+                                ...
+                                ...
+                            ));
+
+// Standalone TRANSFORM
+EXPORT project_name := PROJECT(input_dataset,
+                            TRANSFORM_name(
+                                LEFT)
+                               );">
+</EclCode>
+</pre>
+
+| _Value_ | _Definition_ |
+| :- | :- |
+| EXPORT | Optional, used within MODULEs. |
+| project_name | The name by which the project will be invoked. |
+| PROJECT | Required. |
+
+Please refer to TRANSFORM for TRANSFORM syntax.
+
+### Demo Dataset
+
+| StudentID | Name | ZipCode | Age | Major | isGraduated |
+| :- | :- | :- | :- | :- | :- |
+| 100 | Zorro | 30330 | 26 | History | TRUE |
+| 409 | Dan | 40001 | 26 | Nursing | FALSE |
+| 300 | Sarah | 30000 | 25 | Art | FALSE |
+| 800 | Sandy | 30339 | 20 | Math | TRUE |
+| 202 | Alan | 40001 | 33 | Math | TRUE |
+| 604 | Danny | 40001 | 18 | N/A | FALSE |
+| 305 | Liz | 30330 | 22 | Chem | TRUE |
+| 400 | Matt | 30005 | 22 | Nursing | TRUE |
+
+**Example**
+
+<pre>
+<EclCode
+id="ProjectExp_1"
+tryMe="ProjectExp_1"
+code="/*Project Example:*/
+
+/*
+PROJECT Example:
+Given a student dataset, PROJECT will decide if a student is in-state or not.
+*/
+
+StudentRec := RECORD
+  INTEGER  StudentID;
+  STRING   Name;
+  STRING   ZipCode;
+  INTEGER  Age;
+  STRING   Major;
+  BOOLEAN  isGraduated;
+END;
+
+StudentDS := DATASET([{100, 'Zorro',  '30330', 26, 'History', TRUE}, {409, 'Dan', '40001', 26, 'Nursing', FALSE},
+                     {300, 'Sarah', '30000', 25, 'Art', FALSE}, {800, 'Sandy', '30339', 20, 'Math', TRUE},
+                     {202, 'Alan', '40001', 33, 'Math', TRUE}, {604, 'Danny', '40001', 18, 'N/A', FALSE},
+                     {305, 'Liz',  '30330', 22, 'Chem', TRUE}, {400, 'Matt', '30005', 22, 'Nursing', TRUE}],
+                    studentRec);
+
+StudentsRes_layout := RECORD
+    INTEGER  StudentID;
+    BOOLEAN  InState;
+    INTEGER  Tuition;
+END;
+
+ProjResult := PROJECT(StudentDS,
+                TRANSFORM(StudentsRes_layout,
+                    SELF.InState := IF(LEFT.ZipCode IN ['30330', '30005', '30000'], TRUE, FALSE);
+                    SELF := LEFT; // Assigns StudentID, since it exists in input dataset.
+
+                    // Assigns default values to Tuition since it doesn't exists in input dataset, 
+                    // nor it is defined in this TRANSFORM
+                    SELF := []    // Assigns default values to Tuition since it doesn't exists in input dataset 
+                    ));
+
+OUTPUT(ProjResult, NAMED('ProjResult'));
+
+"></EclCode>
+</pre>
\ No newline at end of file
diff --git a/learnEcl/2700-function.md b/learnEcl/2700-function.md
index 6539680..27701eb 100644
--- a/learnEcl/2700-function.md
+++ b/learnEcl/2700-function.md
@@ -2,3 +2,147 @@
 title: Function
 slug: function
 ---
+
+# FUNCTION
+
+A Function is a set of statements that take inputs, does some specific computation and produces an output or return a result. Result could be a value or a dataset.
+
+Notes
+
+* For function to be called/used from outside, EXPORT is required
+* Function name should match the file name. if not "Error: Definition must contain EXPORT or SHARED " is generated
+
+## Syntax
+
+<pre>
+<EclCode code="EXPORT [return_data_type] function_name (data_type arg [, data_type arg]+) := FUNCTION
+
+    ecl_code
+    RETURN return_value;
+
+END;">
+</EclCode>
+</pre>
+
+| _Value_ | _Definition_ |
+| :- | :- |
+| EXPORT | Optional |
+| return_data_type | Optional (compiler can infer it from return_value). If returning a dataset, the data type is DATASET(record_definition) |
+| function_name | The name by which the function will be invoked |
+| data_type | The argument’s data type. If passing a dataset, the data type is DATASET(record_definition) |
+| ecl_code | Whatever code is needed to build return_value. Conversely, if the code does not contribute to return_value then it is ignored. Attributes defined here are scoped to the function |
+| RETURN | Required |
+| return_value | 	The result of the function |
+| END | Required |
+
+**Example**
+
+<pre>
+<EclCode
+id="FunctionExp_1"
+tryMe="FunctionExp_1"
+code="/*Function Example:*/
+
+/*
+Function Example:
+*/
+
+EXPORT MyFunc (STRING Val) := FUNCTION
+
+   Result := 'Hello ' + Val + ' , welcome to this function';
+   RETURN Result;
+
+END;
+
+// Using MyFunc
+Res := MyFunc('Jonny');
+OUTPUT(Res, NAMED('res'));
+
+OUTPUT(MyFunc('Sunny'), NAMED('Sunny'));
+
+"></EclCode>
+</pre>
+
+## Outputs in Function - Using WHEN
+
+OUTPUT can be used to return multiple results from a function. PARALLEL and WHEN are the keywords used to generate multiple results.
+
+PARALLEL let's you run actions in parallel and WHEN behaves as a trigger. WHEN is used in scheduling.
+
+**Example**
+
+<pre>
+<EclCode
+id="FunctionExp_2"
+tryMe="FunctionExp_2"
+code="/*
+Function Example:
+Outputting multiple values using WHEN.
+*/
+
+Pop_Layout := RECORD
+    STRING   City;
+    STRING   State;
+    STRING   County;
+    INTEGER  Population;
+END;
+Pop_DS := DATASET([
+                {'Dauphin Island','AL','Mobile',1335},
+                {'Guy','AR','Faulkner',778},
+                {'El Centro','CA','Imperial',111425},
+                {'Indio','CA','Riverside',417059},
+                {'Englewood','CO','Arapahoe',6183},
+                {'Keywest','FL','Monroe',31401}], 
+                Pop_Layout);
+
+
+SomeFunc(DATASET(Pop_Layout) Pop_DS) := FUNCTION
+
+
+    Str        := 'This is a WHEN example.';
+    SomeFilter := Pop_DS(Pop_DS.Population >= 50000);
+    MaxPop     := Pop_DS(Population = MAX(Pop_DS, Population));
+
+  SideActions := PARALLEL
+     (
+         OUTPUT(Pop_DS, NAMED('Pop_DS'));
+         OUTPUT(SomeFilter, NAMED('SomeFilter'));
+         OUTPUT(MaxPop, NAMED('MaxPop'));
+     );
+
+  RETURN WHEN(Str, SideActions);
+END;
+
+
+// Calling the SomeFunc function
+
+SomeFunc(Pop_DS);
+
+"></EclCode>
+</pre>
+
+## One Line Function
+If you don't have any ecl_code for the function, it is a one-liner. FUNCTION, RETURN, and END keywords are omitted.
+
+**Example**
+
+<pre>
+<EclCode
+id="FunctionExp_3"
+tryMe="FunctionExp_3"
+code="/*
+FUNCTION Example:
+One line function
+*/
+
+// Squared Function Example
+UNSIGNED2 Squared(UNSIGNED1 n) := n * n;
+
+// isEven Function Example
+isEven(INTEGER num) := num % 2 = 0;
+
+OUTPUT(Squared(3), NAMED('SquaredFunction'));
+OUTPUT(isEven(10), NAMED('isEvenFunction'));
+
+"></EclCode>
+</pre>
\ No newline at end of file
diff --git a/learnEcl/2800-module.md b/learnEcl/2800-module.md
index cd921e1..f18e89c 100644
--- a/learnEcl/2800-module.md
+++ b/learnEcl/2800-module.md
@@ -2,3 +2,120 @@
 title: Module
 slug: module
 ---
+
+# MODULE
+
+MODULE is s a container that allows you to group related definitions and functionalities. The parameters passed to the module are shared by all the related members definitions.
+
+## Notes
+* OUTPUT can not be used within a module
+* For modules to be called/used from outside, EXPORT is required
+* Module name should match the file name. if not "Error: Definition must contain EXPORT or SHARED " is generated
+* To call a module: ModuleName.attributeName;
+
+## Variable Scope
+
+* LOCAL Definitions are visible only up to an EXPORT or SHARED.
+
+* SHARED Definitions are visible through module.
+
+* EXPORT Definitions are visible within and outside of a module.
+
+* Modules can contain multiple, SHARED and EXPORT values.
+
+## Syntax
+
+<pre>
+<EclCode code="EXPORT module_name [ ( parameters ) ] := MODULE
+    ...
+    SHARED
+    ...
+    ...
+    EXPORT
+END">
+</EclCode>
+</pre>
+
+| _Value_ | _Definition_ |
+| :- | :- |
+| EXPORT | 	Optional, indicates that this module is available outside of this file |
+| module_name | The name of the function. |
+| param_data_type | Data type of each parameter (string, integer, Boolean, …). |
+| MODULE | Required. |
+| SHARED | The attribute or function can be accessed within the module. |
+| EXPORT | The attribute or function can be accessed from outside of the module. |
+| END | Indicates the end of module. |
+
+**Example**
+
+<pre>
+<EclCode
+id="ModuleExp_1"
+tryMe="ModuleExp_1"
+code="/*MODULE Example:*/
+
+/*
+MODULE Example:
+Simple MODULE using SHARED AND EXPORT
+*/
+
+MyMod := MODULE
+
+   SHARED ValOne := 12;
+   STRING StrOne := 'abc';
+
+   EXPORT DoMath  :=  ValOne * 12;
+   EXPORT PrintIt := 'Mod is used';
+
+END;
+
+// Calling the module
+OUTPUT(myMod.PrintIt, NAMED('Mod_Call1'));
+OUTPUT(myMod.DoMath, NAMED('Mod_Call2'));
+
+"></EclCode>
+</pre>
+
+**Example**
+
+<pre>
+<EclCode
+id="ModuleExp_2"
+tryMe="ModuleExp_2"
+code="/*MODULE Example:*/
+
+/*
+MODULE Example:
+Simple MODULE using FUNCTION
+*/
+
+MyMod := MODULE
+
+
+   STRING LocalVal := 'This is not visible after EXPORT or SHARED';
+
+   EXPORT SimpleFun(STRING Day, INTEGER Num) := FUNCTION
+
+       Concat := 'Today is ' + Day + ' and your lucky number is: ' + Num;
+       RETURN Concat;
+
+    END;
+    
+    EXPORT SimpleMath(INTEGER Num) := FUNCTION
+
+        Even := (STRING) Num + ' is an Even number';
+        Odd  := (STRING) Num + ' is an Odd number';
+
+        RETURN IF(Num % 2 = 0, Even, Odd);
+    END;          
+       
+END;
+
+// Calling the module
+OUTPUT(MyMod.SimpleFun('Sunday', 45), NAMED('SimpleFun'));
+
+Num := 12;
+OUTPUT(myMod.SimpleMath(Num), NAMED('SimpleMath'));
+
+"></EclCode>
+</pre>
\ No newline at end of file
diff --git a/learnEcl/3000-join.md b/learnEcl/3000-join.md
index 5f3a37c..10dbf1a 100644
--- a/learnEcl/3000-join.md
+++ b/learnEcl/3000-join.md
@@ -2,3 +2,349 @@
 title: Join
 slug: join
 ---
+
+# JOIN
+
+JOIN is used to combine data or rows from two or more tables/datasets based on at least one boolean expression test.
+
+Note: When join condition is on STRING case sensitivity matters. For example Sun, SUN, and sun aren't the same. Make sure your STRING values are the same format to capture the matching dataset correctly.
+
+## Join Types
+
+Inner
+
+Returns all rows from both the dataset if the condition satisfies. This join will create the result-set by combining all rows from both the datasets where the condition satisfies. This is the default JOIN, so it doesn't need to be declared.
+LEFT ONLY
+
+Returns all the rows of the dataset on the left side of the join that didn’t match any rows from right dataset.
+LEFT OUTER
+
+Returns all the rows of the dataset on the left side of the join and matching rows for the dataset on the right side of join.
+RIGHT ONLY
+
+Returns all the rows of the dataset on the right side of the join that didn’t match any rows from left dataset.
+RIGHT OUTER
+
+Returns all the rows of the dataset on the right side of the join and matching rows for the dataset on the left side of join.
+FULL ONLY
+
+Returns all rows from both left and right datasets that don't have a match in opposite dataset.
+FULL OUTER
+
+Returns all rows from both the datasets regardless of join condition. This join will create the result-set by combining all rows from both the datasets, including matched and non matched rows. For non matched rows, the fields from opposite dataset will remain null.
+
+## Syntax
+
+<pre>
+<EclCode code="/*** Join with Explicit Transform ***/
+attribName := JOIN(LEFT_DatasetName,
+                   RIGHT_DatasetName,
+                        // JoinConditions - AND/OR/NOT_Equal
+                        LEFT.fieldName  = RIGHT.fieldName AND
+                        (LEFT.fieldName = RIGHT.fieldName OR,
+                        LEFT.fieldName != RIGHT.fieldName),
+                    TRANSFORM(Result_RecordLayout,
+                            SELF := LEFT,
+                            SELF := RIGHT),
+                    JOINType
+                    [, flags]);
+
+
+/*** Join with stand-alone Transform ***/
+attribName := JOIN(LEFT_DatasetName,
+                   RIGHT_DatasetName,
+                        // JoinConditions - AND/OR/NOT_Equal
+                        LEFT.fieldName  = RIGHT.fieldName AND
+                        (LEFT.fieldName = RIGHT.fieldName OR,
+                        LEFT.fieldName != RIGHT.fieldName),
+                    xFormName(LEFT, RIGHT),
+                    JOINType
+                    [, flags]);">
+</EclCode>
+</pre>
+
+| _Value_ | _Definition_ |
+| :- | :- |
+| attribName | The name by which the function will be invoked. |
+| LEFT_DatasetName | 	Left dataset of the join. LEFT is the first dataset passed to JOIN. |
+| RIGHT_DatasetName | Right dataset of the join. RIGHT is the second dataset passed to JOIN. |
+| LEFT.fieldName = RIGHT.fieldName | Join matching condition, it can use equal (=) or not-equal (!=). Join can take place on multiple conditions can exists using AND/OR. |
+| Transform/xFormName | Explicit or stand-alone TRANSFORM. Keep in mind that you are passing two arguments to JOIN (left dataset and right dataset). |
+| JoinType | Default is Inner join. |
+| Flags | Optional. |
+
+### Optional Flags
+
+LOOKUP
+
+The right dataset is relatively small and there should be only one match for any LEFT record.
+ALL
+
+The right dataset is relatively small and can be copied to every node in its entirety.
+* Can have multiple matches (unlike LOOKUP)
+* Supports join conditions that contain no equalities
+* Required if there are no equality tests in the condition
+FEW
+
+Few Specifies the LOOKUP right dataset has few records, so little memory is used.
+NOSORT
+
+NOSORT Performs the JOIN without dynamically sorting the tables. This implies that the left and/or right record-set must have been previously sorted and partitioned based on the fields specified in the join Condition.
+KEYED
+
+KEYED Specifies using indexed access into the right record-set.
+LOCAL
+
+LOCAL JOIN performed on each supercomputer node independently, and maintains the pervious distribution of data.
+KEEP(n)
+
+KEEP(n) Specifies the maximum number of matching records (n) to generate into the result set. If omitted, all matches are kept.
+LIMIT
+
+LIMIT Specifies a maximum number of matching records which, if exceeded, either fails the job, or eliminates all those matches from the result set.
+
+### Demo Dataset
+
+Left Dataset(StudentDS)
+
+| StudentID | Name | ZipCode | Age | Major | isGraduated |
+| :- | :- | :- | :- | :- | :- |
+| 100 | Zoro | 30330 | 26 | History | TRUE |
+| 409 | Dan | 40001 | 26 | Nursing | FALSE |
+| 300 | Sarah | 30000 | 25 | Art | FALSE |
+| 800 | Sandy | 30339 | 20 | Math | TRUE |
+| 202 | Alan | 40001 | 33 | Math | TRUE |
+| 604 | Danny | 40001 | 18 | N/A | FALSE |
+| 305 | Liz | 30330 | 22 | Chem | TRUE |
+| 400 | Matt | 30005 | 22 | Nursing | TRUE |
+
+Right Dataset(MajorDS)
+
+|MajorID|MajorName|NumOfYears|Department|
+|:-|:-|:-|:-|
+M101 | Dentist | 5 | medical
+M102 | Nursing | 4 | Medical
+M201 | Surgeon | 12 | Medical
+S101 | Math | 4 | Science
+S333 | Computer | 4 | Science
+A101 | Art | 3 | Art
+A102 | Digital Art | 3 | Art
+
+**Example**
+
+<pre>
+<EclCode
+id="JoinExp_1"
+tryMe="JoinExp_1"
+code="/*Join Example:*/
+
+/*
+JOIN Example:
+JOIN examples showing case sensitivity and logical operations
+*/
+
+//Importing standard library for string manipulation 
+IMPORT STD;
+
+StudentRec := RECORD
+  INTEGER  StudentID;
+  STRING   Name;
+  STRING   ZipCode;
+  INTEGER  Age;
+  STRING   Major;
+  BOOLEAN  isGraduated;
+END;
+
+
+StudentDS := DATASET([{100, 'Zorro',  30330, 26, 'History', TRUE}, {409, 'Dan', 40001, 26, 'Nursing', FALSE},
+                     {300, 'Sarah', 30000, 25, 'Art', FALSE}, {800, 'Sandy', 30339, 20, 'MAth', TRUE},
+                     {202, 'Alan', 40001, 33, 'Math', TRUE}, {604, 'Danny', 40001, 18, 'N/A', FALSE},
+                     {305, 'Liz',  30330, 22, 'Chem', TRUE}, {400, 'Matt', 30005, 22, 'nursing', TRUE}],
+                    studentRec);
+
+MajorRec := RECORD
+  STRING  MajorID;
+  STRING  MajorName;
+  INTEGER NumOfYears;
+  STRING  Department;
+END;
+
+MajorDS := DATASET([{'M101', 'Dentist', 5, 'medical'}, {'M102', 'Nursing', 4, 'Medical'}, {'M201', 'Surgeon', 12, 'Medical'},
+                   {'S101', 'Math', 4, 'Science'}, {'S333', 'Computer', 4, 'Science'}, {'A101', 'Art', 3, 'Art'},
+                   {'A102', 'Digital Art', 3, 'Art'}],
+                   majorRec);
+
+getMajorRec := RECORD
+  STRING Name;
+  STRING Major;
+  STRING YearsTotal;
+  STRING Department;
+END;
+
+// Display all students that have a major defined in majorDS 
+// Using ToUpperCase to make sure all values have the same case sensitivity
+WithCase := JOIN(studentDS, majorDS,
+                 STD.Str.ToUpperCase(LEFT.major) = STD.Str.ToUpperCase(RIGHT.MajorName),
+                 TRANSFORM(getMajorRec,
+                           SELF.YearsTotal := (STRING)RIGHT.NumOfYears;
+                           SELF := LEFT;
+                           SELF := RIGHT));
+
+OUTPUT(WithCase, NAMED('WithCase'));
+
+// Display all students that have a major defined in majorDS 
+// Using the string values as they are
+WithoutCase := JOIN(studentDS, majorDS,
+                 LEFT.major = RIGHT.MajorName,
+                 TRANSFORM(getMajorRec,
+                           SELF.YearsTotal := (STRING)RIGHT.NumOfYears;
+                           SELF := LEFT;
+                           SELF := RIGHT));
+
+OUTPUT(WithoutCase, NAMED('WithoutCase'));
+
+// Display all students that have a major defined in majorDS 
+// And have more than 3 years in NumOfYears
+GetStudents := JOIN(studentDS, majorDS,
+                 STD.Str.ToUpperCase(LEFT.major) = STD.Str.ToUpperCase(RIGHT.MajorName) AND
+                 RIGHT.NumOfYears > 3,
+                 TRANSFORM(getMajorRec,
+                           SELF.YearsTotal := (STRING)RIGHT.NumOfYears;
+                           SELF := LEFT;
+                           SELF := RIGHT));
+
+OUTPUT(GetStudents, NAMED('GetStudents'));
+
+"></EclCode>
+</pre>
+
+### Demo Dataset
+
+Left Dataset
+ColorID|Color|isDark
+|---|---|---
+1 | Blue | 1 
+2 | Red | 0
+3 | Black | 1 
+4 | Green | 1
+5 | Olive | 0 
+11 | Maroon | 1
+
+Right Dataset:
+
+ID|Hue|Code|
+---|---|---
+2 | Red | #FF0000 
+3 | Black | #000000
+4 | Green | #008000 
+8 | Green | #FFC0CB
+10 | Red | #000000 
+12 | Lime |#00FF00
+
+**Example**
+
+<pre>
+<EclCode
+id="JoinExp_2"
+tryMe="JoinExp_2"
+code="/*Join Example:*/
+
+/*
+JOIN Example:
+Showing the difference between join types.
+*/
+
+ColorRec := RECORD
+    INTEGER   ColorID;
+    STRING    Color;
+    BOOLEAN   isDark;
+END;
+
+ColorsDS := DATASET([{1, 'Blue', 1}, {2, 'Red', 0},
+                     {3, 'Black', 1}, {4, 'Green', 1},
+                     {5, 'Olive', 0}, {11, 'Maroon', 1}], 
+                     ColorRec);
+
+
+ColorCodeRec := RECORD
+    INTEGER ID;
+    STRING  Hue;
+    STRING  Code;
+END;
+
+ColorCodeDS := DATASET([{2, 'Red', '#FF0000'}, {3, 'Black', '#000000'},
+                        {4, 'Green', '#008000'}, {8, 'Green', '#FFC0CB'},
+                        {10, 'Red', '#000000'}, {12, 'Lime', '#00FF00'}],
+                        ColorCodeRec);
+
+ColorResRec := RECORD
+    INTEGER  ColorID;
+    STRING   Color;
+    STRING   Hue;
+    STRING   ColorCode;
+    STRING   Category;
+END;
+
+
+
+//***************************************************************************
+// LEFT ONLY 
+LeftOnly := JOIN(ColorsDS,   // LEFT dataset
+                ColorCodeDS, // RIGHT dataset
+                 LEFT.ColorID = RIGHT.ID,   // Marching condition
+                 TRANSFORM(ColorResRec, 
+                    SELF.ColorCode := RIGHT.Code,
+                    SELF.Category  := IF(LEFT.isDark, 'Dark', 'Bright'),
+                    SELF := LEFT,
+                    SELF := RIGHT
+                    ),
+                    LEFT ONLY);
+                     
+OUTPUT(LeftOnly, NAMED('LeftOnly'));
+
+//***************************************************************************
+// LEFT Outer
+LeftOuter := JOIN(ColorsDS,   // LEFT dataset
+                ColorCodeDS, // RIGHT dataset
+                 LEFT.ColorID = RIGHT.ID,   // Marching condition
+                 TRANSFORM(ColorResRec, 
+                    SELF.ColorCode := RIGHT.Code,
+                    SELF.Category  := IF(LEFT.isDark, 'Dark', 'Bright'),
+                    SELF := LEFT,
+                    SELF := RIGHT
+                    ),
+                    LEFT Outer);
+                     
+OUTPUT(LeftOuter, NAMED('LeftOuter'));
+
+//***************************************************************************
+// FULL ONLY
+FullOnly := JOIN(ColorsDS, 
+                ColorCodeDS,
+                 LEFT.ColorID = RIGHT.ID,
+                 TRANSFORM(ColorResRec, 
+                    SELF.ColorCode := RIGHT.Code,
+                    SELF.Category  := IF(LEFT.isDark, 'Dark', 'Bright'),
+                    SELF := LEFT,
+                    SELF := RIGHT
+                    ),
+                    FULL ONLY);
+                     
+OUTPUT(FullOnly, NAMED('FullOnly'));
+
+// Full OUTER
+FullOuter := JOIN(ColorsDS, 
+                ColorCodeDS,
+                 LEFT.ColorID = RIGHT.ID,
+                 TRANSFORM(ColorResRec, 
+                    SELF.ColorCode := RIGHT.Code,
+                    SELF.Category  := IF(LEFT.isDark, 'Dark', 'Bright'),
+                    SELF := LEFT,
+                    SELF := RIGHT
+                    ),
+                    FULL OUTER);
+                     
+OUTPUT(FullOuter, NAMED('FullOuter'));
+
+"></EclCode>
+</pre>
\ No newline at end of file
diff --git a/learnEcl/3100-table.md b/learnEcl/3100-table.md
index 64faf5b..e8cc1d9 100644
--- a/learnEcl/3100-table.md
+++ b/learnEcl/3100-table.md
@@ -2,3 +2,236 @@
 title: Table
 slug: table
 ---
+
+# TABLE
+
+TABLE is the most commonly-used data aggregation functions in ECL. It creates a new dataset in memory while workunit is running. The new table inherits the implicit rationality the recordset has (if any), unless the optional expression is used to perform aggregation. There are two types of Table:
+
+Vertical Number of records in the input dataset is equal to generated table, which means no aggregation is involved.
+
+CrossTab There is at least one field using an aggregate function with the keyword Grouping Condition as its first parameter. The number of records produced is equal to the number of distinct values of the expression.
+
+## Syntax
+
+<pre>
+<EclCode code="/*** Stand-alone record definition ***/
+out_record_def := RECORD
+              dataset.field;
+              dataset.field;
+              ...
+              field_name := Agg_Func(GROUP, dataset.field);
+              field_name := Agg_Func(GROUP, dataset.field);
+              field_name := COUNT(GROUP);
+              ....
+END;
+
+attr_name := TABLE(dataset,
+                    out_record_def,
+                    grouping-conditions
+                    [, flags]
+                    );">
+</EclCode>
+</pre>
+
+| _Value_ | _Definition_ |
+| :- | :- |
+| out_record_def | Record definition that will contain both the grouping condition results and any new attributes computed as part of the aggregation. |
+| dataset.field | Field(s) from input dataset. |
+| field_name | Newly defined fields. |
+| attr_name | The name by which the table will be invoked. |
+| TABLE | Required. |
+| dataset | Input dataset to create the table from. |
+| grouping_condition | One or more comma-delimited expressions. Please see Grouping Condition for more information. |
+| flags | Optional flags that can alter the behavior of TABLE. |
+
+<pre>
+<EclCode code="/*** Implicit record definition ***/
+attr_name := TABLE(dataset,
+                    {
+                      field,  //Calling specific field from input dataset
+                      field,
+                      ...
+                      field_name := Agg_Func(GROUP, dataset.field);
+                      field_name := Agg_Func(GROUP, dataset.field);
+                      field_name := COUNT(GROUP);
+                      ....
+                    },
+                    grouping_conditions
+                    [, flags]
+                    );">
+</EclCode>
+</pre>
+
+| _Value_ | _Definition_ |
+| :- | :- |
+| attr_name | The name by which the table will be invoked. |
+| TABLE | Required. |
+| field | Field(s) from input dataset. |
+| field_name | 	Newly defined field. |
+| grouping_condition | One or more comma-delimited expressions. Please see Group for more information. |
+| flags | Optional flags that can alter the behavior of TABLE. |
+
+### Grouping Condition
+
+* One or more comma-delimited expressions
+* An expression could simply be an attribute name within the dataset; this is the most common usage
+* An expression could be a computed value, such as (myValue % 2) to group on even/odd values
+* All records within dataset that evaluate to the same set of condition values will be grouped together
+* Each group will result in one output record
+* Functions evaluated within outrecorddef will operate on the group
+
+### Optional Flags
+
+Flags can alter the behavior of TABLE. Commonly used flags are MERGE and LOCAL
+
+| _Flag_ | _Definition_ |
+| :- | :- |
+| FEW | Indicates that the expression will result in fewer than 10,000 distinct groups. This allows optimization to produce a significantly faster result. |
+| MANY | Indicates that the expression will result in many distinct groups. |
+| UNSORTED | Specifies that you don't care about the order of the groups. This allows optimization to produce a significantly faster result. |
+| LOCAL | Specifies the operation is performed on each node independently; the operation maintains the distribution of any previous DISTRIBUT. |
+| KEYED | Specifies the activity is part of an index read operation, which allows the optimizer to generate optimal code for the operation. |
+| MERGE | Specifies that results are aggregated on each node and then the aggregated intermediaries are aggregated globally. This is a safe method of aggregation that shines particularly well if the underlying data was skewed. |
+| SKEW | Indicates that you know the data will not be spread evenly across nodes. |
+
+## GROUP
+
+The GROUP keyword is used within output format parameter (RECORD Structure) of a TABLE definition. GROUP replaces the recordset parameter of any aggregate built-in function used in the output to indicate the operation is performed for each group of the expression. This is similar to an SQL "GROUP BY" clause.
+
+
+### Demo Dataset
+
+| Pickup_Date | Fare | Distance |
+| :- | :- | :- |
+| 1/1/2021 | 25.1 | 15.5 |
+| 1/2/2021 | 40.15 | 7.2 |
+| 1/3/2021 | 25.36 | 6.5 |
+| 1/2/2021 | 120 | 23 |
+| 1/3/2021 | 30 | 60.75 |
+| 2/2/2021 | 25 | 71 |
+| 1/2/2021 | 10 | 2.2 |
+| 3/10/2021 | 45 | 12.23 |
+
+
+**Example**
+
+<pre>
+<EclCode
+id="TableExp_1"
+tryMe="TableExp_1"
+code="/*Table Example:*/
+
+/*
+TABLE Example:
+TABLE is used with aggregations
+*/
+
+// Input layout
+Fare_Layout  :=  RECORD
+    STRING Pickup_Date;
+    REAL   Fare;
+    REAL   Distance;
+END;
+
+// Input dataset
+FareDS := DATASET([
+                   {'1/1/2021', 25.1, 15.5}, {'1/2/2021', 40.15,7.2},
+                   {'1/3/2021', 25.36, 6.5}, {'1/2/2021', 120, 23},
+                   {'1/3/2021', 30, 60.75}, {'2/2/2021', 25, 71},
+                   {'1/2/2021', 10, 2.2}, {'3/10/2021', 45, 12.23}],
+                   Fare_Layout);
+
+// Defining all fields for the table
+AvgRide_Layout := RECORD
+   fareDS.pickup_date;                   // Calling specific field from input dataset
+   avgFare   := AVE(GROUP, fareDS.fare); // Calculating avg fare per each group
+   totalFare := SUM(GROUP, fareDS.fare); // Calculating total fare per each group
+END;
+
+crossTabDs := TABLE(FareDS,           // Input dataset. please see dataset above
+                     AvgRide_Layout,  // Result table definition
+                     pickup_date      // Grouping field
+                     );
+
+OUTPUT(crossTabDs, NAMED('crossTabDs'));
+
+"></EclCode>
+</pre>
+
+### Demo Dataset
+
+| PersonID | FirstName | LastName | isEmployed | avgIncome | EmpGroupNum |
+| :- | :- | :- | :- | :- | :- |
+| 1102 | Fred | Smith | FALSE | 1000 | 900 |
+| 3102 | Fact | Smith | TRUE | 200000 | 100 |
+| 1012 | Joe | Blow | TRUE | 11250 | 200 |
+| 2085 | Blue | Moon | TRUE | 185000 | 500 |
+| 3055 | Silver | Jo | FALSE | 5000 | 900 |
+| 1265 | Darling | Jo | TRUE | 5000 | 100 |
+| 1265 | Darling | Alex | TRUE | 5000 | 100 |
+| 5265 | Blue | Silver | TRUE | 75000 | 200 |
+| 7333 | Jane | Smith | FALSE | 50000 | 900 |
+| 6033 | Alex | Silver | TRUE | 102000 | 200 |
+| 1024 | Nancy | Moon | TRUE | 201100 | 700 |
+
+**Example**
+
+<pre>
+<EclCode
+id="TableExp_2"
+tryMe="TableExp_2"
+code="/*Table Example:*/
+
+/*
+TABLE Example:
+Cross table example.
+*/
+
+AllPeople_Layout := RECORD
+  UNSIGNED  PersonID;
+  STRING15  FirstName;
+  STRING25  LastName;
+  BOOLEAN   isEmployed;
+  UNSIGNED  AvgIncome; 
+  INTEGER   EmpGroupNum;
+END;
+
+
+AllPeopleDS := DATASET([ 
+                       {1102,'Fred','Smith', FALSE, 1000, 900},
+                       {3102,'Fact','Smith', TRUE, 200000, 100},
+                       {1012,'Joe','Blow', TRUE, 11250, 200},
+                       {2085,'Blue','Moon', TRUE, 185000, 500},
+                       {3055,'Silver','Jo', FALSE, 5000, 900},
+                       {1265,'Darling','Jo', TRUE, 5000, 100},
+                       {1265,'Darling','Alex', TRUE, 5000, 100},
+                       {5265,'Blue','Silver', TRUE, 75000, 200},
+                       {7333,'Jane','Smith', FALSE, 50000, 900},
+                       {6023,'Alex','Silver',TRUE, 102000, 200},
+                       {1024,'Nancy','Moon', TRUE, 201100, 700}],
+                       AllPeople_Layout);
+
+VerticalSlice := Table(AllPeopleDS,
+                        {
+                          LastName,
+                          isEmployed
+                        },
+                        LastName, isEmployed);
+OUTPUT(VerticalSlice, NAMED('VerticalSlice'));
+
+
+AvgIncome := TABLE(AllPeopleDS,
+                    {
+                      LastName,
+                      AvgHouseIncome := AVE(GROUP, AvgIncome)
+                    },
+                    LastName);
+
+OUTPUT(AvgIncome, NAMED('AvgIncome'));
+
+    
+  
+
+
+"></EclCode>
+</pre>
\ No newline at end of file
diff --git a/learnEcl/3200-normalize.md b/learnEcl/3200-normalize.md
index 82c7d1c..29fc586 100644
--- a/learnEcl/3200-normalize.md
+++ b/learnEcl/3200-normalize.md
@@ -2,3 +2,214 @@
 title: Normalize
 slug: normalize
 ---
+
+# NORMALIZE
+
+NORMALIZE gets a parent-child (DENORMALIZED) dataset and extract the child dataset from it. The purpose is to take variable-length flat-file records and split out the child information.
+
+There are two ways to normalize a child dataset:
+
+* All Records: Processing all child records
+* With Counter: Using counter for a certain number of children
+
+## Normalize All Records
+
+This form processes through all records in the recordset executing transform function through all the child dataset records in each record. This method is used when we have embedded child dataset.
+
+You can think of this as a specialized JOIN where the TRANSFORM is called with, LEFT as the “main” record being processed and RIGHT as one of the records from the child dataset.
+
+In this form TRANSFORM is called for each parent record with child record pair.
+
+## Parameters
+* Must have a RIGHT record of the same format as the child dataset.
+* The resulting record set format does not need to be the same as the input.
+* Child layout is being called as an embedded dataset.
+
+**Example**
+
+<pre>
+<EclCode
+id="NormalizeExp_1"
+tryMe="NormalizeExp_1"
+code="/*Normalize Example:*/
+
+/*
+Normalize Example:
+NORMALIZE All Records
+*/
+
+// Child layout that's being extract  from parent
+Child_Layout := RECORD
+    INTEGER1 NameID;
+    STRING20 Addr; 
+END;
+
+// Parent Layout with child dataset 
+Parent_Layout := RECORD
+    INTEGER1 NameID;
+    STRING20 Name;
+    DATASET(Child_Layout) Children; //Embedded child layout
+END;
+
+// Parent dataset with child dataset
+parentDS := DATASET([ 
+                       {1,'Kevin',   [ {1, '290 Downtown Abby'}] },
+                       {2,'Liz',     [ {2, '2345 Lake View Rd'}, {2, '776  Action Cir'}] },
+                       {3,'Jacob',   [ ]},
+                       {4,'Alex',    [ {4, '9000 Sunset Blvd'}] },
+                       {5,'Sally',   [ {5, '345 Fresh Start Str'}, {5,  '433 Union Dr'} ,
+                                       {5,  '777 Lookup Court'},   {5,  '222 Movie Str'} ] }
+                    ], Parent_Layout);
+
+OUTPUT(parentDS, NAMED('parentDS'));
+
+
+Child_Layout xForm(Child_Layout Ri) := TRANSFORM
+     SELF := Ri;
+END;
+
+ExtractChild := NORMALIZE(parentDS,
+                         LEFT.Children, //Sending only the child dataset
+                         xForm(RIGHT));
+
+
+OUTPUT(ExtractChild, NAMED('ExtractChild'));
+
+"></EclCode>
+</pre>
+
+## All Records Syntax
+
+<pre>
+<EclCode code="Child_Layout := RECORD
+    FieldOne;
+    FieldTwo;
+END;
+
+//Parent Layout with child dataset
+Parent_Layout := RECORD
+    ...
+    ...
+    DATASET(Child_Layout) Children; //Embedded child layout
+END;
+
+Child_Layout xForm(Child_Layout Ri) := TRANSFORM
+     SELF := Ri;
+END;
+
+attribName := NORMALIZE(ParentsDS,
+                         //Sending only the child dataset
+                         LEFT.Children, 
+                         xForm(RIGHT)
+                         [,flags]);">
+</EclCode>
+</pre>
+
+## Normalize With COUNTER
+
+This NORMALIZE form calls TRANSFORM times for each parent record. does not need to be the same value for every record. The TRANSFORM function must take at least a LEFT record of the same format as the input recordset. The resulting record set format does not need to be the same as the input.
+
+**Example**
+
+<pre>
+<EclCode
+id="NormalizeExp_2"
+tryMe="NormalizeExp_2"
+code="/*Normalize Example:*/
+
+/*
+NORMALIZE with COUNTER Example
+*/
+
+Parent_layout := RECORD
+  // The explicitCount defines:
+  // how many times transform should execute per record.
+  INTEGER explicitCount; 
+  STRING  lastName; 
+  STRING  phoneOne;
+  STRING  phoneTwo;
+  STRING  addressOne;
+  STRING  addressTwo;
+  STRING  addressThree;
+END;
+
+// Parent Dataset
+parentDS := DATASET([
+                {2, 'Alexa', '7701234567',  '', '123 Main Str', '404 capital cr', ''},
+                {2, 'Smith', '', '8890002323', '504 Sunset Blvd', '990 Rose highway', ''},
+                
+                //Notice Adam has two phone numbers, but assigning 1 for number of execution
+                {1, 'Adam', '6789991111', '4445679000', '', '', ''},
+                {2, 'Black', '5694023457' ,'', '777 Formal Str', '111 Batman Corner', ''},
+                {3, 'Rosy', '2209875437', '', '8749 OceanFront main Rd','5671 North Lake Str', '2323 Washington RD'}],
+                      Parent_layout);
+
+
+OUTPUT(parentDS, NAMED('parentDS'));
+
+child_layout := RECORD
+  INTEGER    countIt;
+  STRING     Name;
+  STRING     phone; 
+  STRING     address;
+END;
+
+
+child_layout xForm(Parent_layout Li, INTEGER counting) := TRANSFORM
+
+        SELF.countIt    := counting;      
+        SELF.name       := Li.lastName;
+        SELF.phone      := CHOOSE(counting, Li.phoneOne, Li.phoneTwo);
+        SELF.address    := CHOOSE(counting, Li.addressOne, Li.addressTwo, Li.addressThree);
+END;
+  
+extractChild := NORMALIZE(parentDS,
+                          //Number of times transform should go through a record
+                          LEFT.explicitCount, 
+                          xForm(LEFT,COUNTER));
+
+OUTPUT(extractChild, NAMED('extractChild'));
+
+"></EclCode>
+</pre>
+
+## With COUNTER Syntax
+
+<pre>
+<EclCode code="Child_Layout := RECORD
+    ...
+    ...
+END;
+
+//Parent Layout with child dataset
+Parent_Layout := RECORD
+    INTEGER TheCounter;
+    ...
+    ...
+END;
+
+
+Child_Layout xForm(Parent_layout Li, INTEGER counting) := TRANSFORM
+
+        //counting will only execute the number of times defined by expression
+        SELF.Result     := CHOOSE(Counting, Li.FieldOne, Li.FieldTwo, ...);
+       ...
+       ...
+
+END;
+
+ExtractChildren := NORMALIZE(ParentDS,
+                            Expression, //Left.TheCounter
+                            xForm(LEFT,COUNTER)
+                            [,flags]);">
+</EclCode>
+</pre>
+
+## Flags
+
+| Options | Description |
+| :- | :- |
+| UNORDERED | Specifies the output record order is not significant. |
+| ORDERED | Specifies the significance of the output record order. |
+| STABLE | Specifies the input record order is significant. |
+| PARALLEL | Try to evaluate this activity in parallel. |
\ No newline at end of file