diff --git a/modevo-script/pom.xml b/modevo-script/pom.xml
index dcd593e..2382e17 100644
--- a/modevo-script/pom.xml
+++ b/modevo-script/pom.xml
@@ -32,6 +32,15 @@
 			<groupId>junit</groupId>
 			<artifactId>junit</artifactId>
 		</dependency>
+		<dependency>
+			<groupId>org.projectlombok</groupId>
+			<artifactId>lombok</artifactId>
+		</dependency>
+		<dependency>
+		    <groupId>com.datastax.cassandra</groupId>
+		    <artifactId>cassandra-driver-core</artifactId>
+		    <version>3.11.5</version>
+		</dependency>
 	</dependencies>
 	<build>
 		<plugins>
@@ -54,7 +63,8 @@
 			<plugin>
 				<groupId>org.apache.maven.plugins</groupId>
 				<artifactId>maven-javadoc-plugin</artifactId>
-			</plugin>			
+			</plugin>	
+					
 		</plugins>
 	</build>
 </project>
\ No newline at end of file
diff --git a/modevo-script/src/main/java/giis/modevo/migration/script/ColumnValue.java b/modevo-script/src/main/java/giis/modevo/migration/script/ColumnValue.java
new file mode 100644
index 0000000..2df2a03
--- /dev/null
+++ b/modevo-script/src/main/java/giis/modevo/migration/script/ColumnValue.java
@@ -0,0 +1,15 @@
+package giis.modevo.migration.script;
+
+import giis.modevo.model.schema.Column;
+import lombok.Getter;
+import lombok.Setter;
+@Getter @Setter
+public class ColumnValue {
+	private Column column;
+	private Select selectOrigin;
+	private String[] key;
+	private String value; //String generic type, actual type in DB could be different
+	private String variableName;
+	private Column columnSelectOrigin;
+	
+}
diff --git a/modevo-script/src/main/java/giis/modevo/migration/script/For.java b/modevo-script/src/main/java/giis/modevo/migration/script/For.java
new file mode 100644
index 0000000..f4bb5cf
--- /dev/null
+++ b/modevo-script/src/main/java/giis/modevo/migration/script/For.java
@@ -0,0 +1,29 @@
+package giis.modevo.migration.script;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import lombok.Getter;
+import lombok.Setter;
+
+@Getter @Setter
+public class For {
+	private List<Select> selectsFor;
+	private List<Select> selectsInsideFor;
+	
+ 	private For nestedFor;
+	public For () {
+		selectsFor = new ArrayList<>();
+		selectsInsideFor = new ArrayList<>();
+	}
+	/**
+	 * Class that creates a For object to loop a SELECT statement.
+	 */
+	public void newForSelect (Select s) {
+		this.getSelectsFor().add(s);
+		For oldFor = s.getInsideFor();
+		oldFor.setNestedFor(this); //might change to a list
+		s.setLoopFor(this);
+		s.setInsideFor(null);
+	}
+}
diff --git a/modevo-script/src/main/java/giis/modevo/migration/script/Insert.java b/modevo-script/src/main/java/giis/modevo/migration/script/Insert.java
new file mode 100644
index 0000000..40df6b2
--- /dev/null
+++ b/modevo-script/src/main/java/giis/modevo/migration/script/Insert.java
@@ -0,0 +1,56 @@
+package giis.modevo.migration.script;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import giis.modevo.model.schema.Column;
+import giis.modevo.model.schema.Table;
+import lombok.Getter;
+import lombok.Setter;
+@Getter @Setter
+public class Insert {
+	private List<ColumnValue> columnValue;
+	private Table table;
+	private For insideFor;
+	private String insertStatement;
+	private String nameNewTable; //Only used when a new table is required when adding a new column
+	public Insert() {
+		columnValue = new ArrayList<>();
+	}
+	public Insert(Table table) {
+		this();
+		this.table = table;
+	}
+	public Insert(Table table, For insideFor) {
+		this(table);
+		this.insideFor = insideFor;
+	}
+	/**
+	 * Adds in a ColumnValue object the information of the column to insert, the source of the data and, optionally, 
+	 * the columns used to synchronize the migration
+	 * @param key If there is no key, value is null
+	 * @param target 
+	 */
+	public void addColumnValue(Column columnSelect, Select s, String[] key, Column target) {
+		ColumnValue cv = new ColumnValue ();
+		cv.setColumn(target);
+		cv.setSelectOrigin(s);
+		cv.setKey(key);
+		cv.setColumnSelectOrigin(columnSelect);
+		this.getColumnValue().add(cv);		
+	}
+	public String getNameNewTable() {
+		return nameNewTable;
+	}
+	public void setNameNewTable(String nameNewTable) {
+		this.nameNewTable = nameNewTable;
+	}
+	public String getNameTable() {
+		String name = this.getTable().getName();
+		if (!this.getNameNewTable().isEmpty()) {
+			name = this.getNameNewTable();
+		}
+		return name;
+	}
+	
+}
diff --git a/modevo-script/src/main/java/giis/modevo/migration/script/MainScript.java b/modevo-script/src/main/java/giis/modevo/migration/script/MainScript.java
new file mode 100644
index 0000000..3d65a8f
--- /dev/null
+++ b/modevo-script/src/main/java/giis/modevo/migration/script/MainScript.java
@@ -0,0 +1,33 @@
+package giis.modevo.migration.script;
+
+import java.util.List;
+
+import giis.modevo.migration.script.execution.CassandraConnection;
+import giis.modevo.migration.script.execution.ScriptExecution;
+import giis.modevo.model.ModelObjects;
+import lombok.extern.slf4j.Slf4j;
+
+/**
+ * 
+ * Main Class to call for the creation of scripts. It receives the models as objects and calls first the method to create
+ * the script object and then, the method to create the textual script.
+ */
+@Slf4j
+public class MainScript {
+	
+	public String createScriptAndText (ModelObjects models, CassandraConnection c, String nameKeyspace) {
+		List<Script> scripts =  new Script().createScript(models.getSchema(), models.getSchemaEvolution(), models.getDataMigration());
+		if (scripts.isEmpty()) {
+			log.info("Scenario not implemented yet");
+			return null;
+		}
+		StringBuilder sb = new StringBuilder();
+		for (Script script : scripts) {
+			log.info("Execution script");
+			sb.append(new ScriptText().writeScript(script));
+			new ScriptExecution().execute (script, c, nameKeyspace);
+		}
+		
+		return sb.toString();
+	}
+}
diff --git a/modevo-script/src/main/java/giis/modevo/migration/script/Script.java b/modevo-script/src/main/java/giis/modevo/migration/script/Script.java
new file mode 100644
index 0000000..9874c79
--- /dev/null
+++ b/modevo-script/src/main/java/giis/modevo/migration/script/Script.java
@@ -0,0 +1,270 @@
+package giis.modevo.migration.script;
+
+import java.util.ArrayList;
+import java.util.Iterator;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+
+import giis.modevo.model.ModelUtilities;
+import giis.modevo.model.datamigration.DataMigration;
+import giis.modevo.model.datamigration.MigrationColumn;
+import giis.modevo.model.datamigration.MigrationTable;
+import giis.modevo.model.schema.Column;
+import giis.modevo.model.schema.Schema;
+import giis.modevo.model.schema.Table;
+import giis.modevo.model.schemaevolution.SchemaEvolution;
+import lombok.Getter;
+import lombok.Setter;
+import lombok.extern.slf4j.Slf4j;
+
+/**
+ * Main class for the creation of the script. First, it receives the information of the models (Schema, Schema evolution and Data Migration) to create a Script object
+ * that contains all the necessary data to execute the data migration.
+ */
+@Getter @Setter @Slf4j
+public class Script {
+
+	private static final String MIGRATION_FOR_COLUMN = "Migration for column %s";
+	
+	private List<Select> selects;
+	private List<For> fors;
+	private List<For> forsHigherLevel; //These are the For loops that are not inside other For loops
+	private List<Insert> inserts;
+	private ScriptText scriptText;
+	private boolean executable;
+	public Script () {
+		setExecutable(true);//default value
+		selects = new ArrayList<>();
+		fors = new ArrayList<>();
+		inserts = new ArrayList<>();
+		setForsHigherLevel(new ArrayList<>());
+		scriptText = new ScriptText();
+	}	
+	public boolean isExecutable() {
+		return executable;
+	}
+	public void setExecutable(boolean executable) {
+		this.executable = executable;
+	}
+	/**
+	 * Main class to start the creation of the script objects
+	 */
+	public List<Script> createScript (Schema schema, SchemaEvolution se, DataMigration dm) {
+		List<Script> scripts = new ArrayList<>();
+		for (MigrationTable mt : dm.getMigrationTables()) {
+			if ( mt.migrationFromSeveralTablesNewTable(schema)) {
+				scripts.add(migrationNewTable (schema, se, mt, true));
+			}
+			else if (mt.migrationFromOneTableNewTable(schema)) {
+				scripts.add(migrationNewTable (schema, se, mt, false));
+			}
+			else if (mt.migrationNewColumn(schema) && !mt.migrationFromRemovePK(se, mt)) {
+				scripts.add(migrationNewColumn (schema, se, mt));
+			}
+			else {
+				return new ArrayList<>(); //Scenarios not implemented
+			}
+		}
+		checkIfExecutable(scripts);
+		return scripts;
+	}
+
+	private void checkIfExecutable(List<Script> scripts) {
+		for (Script s: scripts) {
+			for (Insert i: s.getInserts()) {
+				List<Column> keys =i.getTable().getKey();
+				for (Column key : keys) {
+					if (!inList(key, i.getColumnValue())) {
+						s.setExecutable(false);
+					}
+				}
+			}
+		}
+		
+	}
+	private Script migrationNewTable (Schema schema, SchemaEvolution se, MigrationTable mt, boolean severalTables) {
+		Script s = migrationNewTableAll(schema, se, mt);
+		if (severalTables) {
+			migrationFromSeveralTables (schema, se, mt, s);
+		}
+		return s;
+	}
+	/**
+	 * Adds the neccesary information for an existing script of a new migration for a new table when the data is obtained from more than one table
+	 */
+	private Script migrationFromSeveralTables(Schema schema, SchemaEvolution se, MigrationTable mt, Script script) {
+		log.info("New Table Script from several source tables. Target table: %s", mt.getName());
+		ModelUtilities mu = new ModelUtilities ();
+		List <MigrationColumn> migrationColumnsWithKey = mt.getMigrationColumnsWithKey();
+		//These are always the first insert and select of the script which had been added for the columns that do not require key columns for the migrations
+		Insert insert = script.getInserts().get(0);
+		Select select = script.getSelects().get(0);
+		/*
+		 * Association in the Insert statement of the columns that require an addition query to another table different from the one being looped in the FOR.
+		 * These additional queries will use data in the WHERE clause obtained from their iteration of the loop
+		 */
+		for (MigrationColumn mc: migrationColumnsWithKey) {
+			log.info(MIGRATION_FOR_COLUMN, mc.getName());
+			String nameTable = mc.getColFrom().getTable();
+			if (select.getTable() == null) {
+				select.setTable(mu.findTable(schema, se, nameTable));
+			}
+			String nameColumn =  mc.getColTo().getData(); //nameOfColumn where data will be migrated
+			String[] keyColumnTo = mc.getColTo().getKey();
+			String[] keyColumnFrom = mc.getColFrom().getKey();
+			Table from = schema.getTable(nameTable);
+			Column c= mu.findColumn (schema,se,from.getName(),nameColumn);
+			Select selectInside = script.insertSelect(c, from, keyColumnFrom, schema);
+			Column target = mu.findColumn(schema, se, mc.getColTo().getTable(), mc.getColTo().getData());
+			//Includes the information required to insert the data queries by 'select' in an iteration into 'target'.
+			insert.addColumnValue (c, selectInside, keyColumnTo, target);
+		}
+		return script;
+	}
+	/**
+	 * Creates the script needed for the migration of a new table.
+	 */
+	private Script migrationNewTableAll(Schema schema, SchemaEvolution se, MigrationTable mt) {
+		log.info("New Table Script from one source table. Target table: %s", mt.getName());
+		//Initialization of Script object for the migration of a table
+		Script script = new Script ();
+		ModelUtilities mu = new ModelUtilities ();
+		//Initilization of first For statement, Select looped by the for and the Insert inside the loop  
+		For firstFor = new For ();
+		Select s = new Select (firstFor);
+		firstFor.getSelectsFor().add(s);
+		Table to = mu.findTable (schema, se, mt.getName());
+		Insert insert = new Insert( to, firstFor);
+		insert.setNameNewTable(mt.getNewTableName());
+		List <MigrationColumn> migrationColumnsWithoutKey = mt.getMigrationColumnsWithoutKey();
+		script.addForSelectInsert (firstFor, s, insert);
+		script.getForsHigherLevel().add(firstFor);
+		//Association in the Insert statement and SELECT statement of the columns that will get the data from the SELECT statement this SELECT statement
+		for (MigrationColumn mc: migrationColumnsWithoutKey) {
+			log.info(MIGRATION_FOR_COLUMN, mc.getName());
+			String nameColumn = mc.getColFrom().getData(); 
+			String nameTable = mc.getColFrom().getTable();
+			Column c= mu.findColumn (schema,se,nameTable,nameColumn);
+			if (s.getTable() == null) {
+				s.setTable(mu.findTable(schema, se, nameTable));
+			}
+			//Includes the information required to obtain data from column 'c'
+			s.addColumnSearch (schema, se, nameTable, c);
+			Column target = mu.findColumn(schema, se, mc.getColTo().getTable(), mc.getColTo().getData());
+
+			//Includes the information required to insert the data queries by 's' in an iteration into 'c'
+			insert.addColumnValue (c, s, null, target);
+		}
+		return script;
+	}
+	/**
+	 * Creates the script when there is one or more new columns in a table
+	 */
+	private Script migrationNewColumn(Schema schema, SchemaEvolution se, MigrationTable mt) {
+		log.info("New Column Script");
+		//Initialization of Script object for the migration of a table
+		Script script = new Script ();
+		ModelUtilities mu = new ModelUtilities ();
+		//Because the migration consists on adding data to an existing table, there will always be at least one key column for the migration
+		List <MigrationColumn> migrationColumns = mt.getMigrationColumnsWithKey();
+		Map<String, List<MigrationColumn>> mcsBySourceTable = mt.classifyMCsBySourceTable (migrationColumns);
+		Set<String> nameSourceTables = mcsBySourceTable.keySet();
+		Iterator<String> iterator = nameSourceTables.iterator();
+		//A For-Select-Insert operation will be created to loop over the values to be inserted from each source table into the target table
+		while (iterator.hasNext()) {
+			String nameTable = iterator.next();
+			For forSourceKey;
+			Table targetTable = schema.getTable(mt.getName());
+			Select selectTargetKey = new Select().getSelectSourceValueWhere(targetTable.getKey(), script.getSelects());
+			boolean existed = true;
+			//If no For-Select statements had been found for this source table, a new one is created
+			if (selectTargetKey == null) {
+				log.info("New SELECT to table %s", targetTable);
+				existed = false;
+				forSourceKey = new For ();
+				selectTargetKey = new Select (forSourceKey, targetTable);
+				forSourceKey.getSelectsFor().add(selectTargetKey);
+				script.getSelects().add(selectTargetKey);
+				script.getForsHigherLevel().add(forSourceKey);
+				script.getFors().add(forSourceKey);
+			}
+			else {
+				log.info("Using existing SELECT to table %s", targetTable);
+				forSourceKey = selectTargetKey.getLoopFor();
+			}
+			Insert insertTarget = new Insert(targetTable, forSourceKey);
+			insertTarget.setNameNewTable(mt.getNewTableName());
+			log.info("New INSERT for table %s", mt.getNewTableName());
+
+			//All columns from key of the existing table will be queried
+			for (Column keyColumn:targetTable.getKey()) {
+				if (!existed) {
+					selectTargetKey.getSearch().add(keyColumn);
+				}
+				insertTarget.addColumnValue(keyColumn, selectTargetKey, null, keyColumn); //same column target and source
+			}
+			List<MigrationColumn> keysTarget = mcsBySourceTable.get(nameTable);
+			Table sourceTable = schema.getTable(nameTable);
+			for (MigrationColumn mc : keysTarget) {
+				log.info(MIGRATION_FOR_COLUMN, mc.getName());
+				String nameColumn =  mc.getColFrom().getData(); //nameOfColumn where data will be migrated
+				String[] keyColumnTo = mc.getColTo().getKey();
+				String[] keyColumnFrom = mc.getColFrom().getKey();
+				Column c= mu.findColumn (schema,se,sourceTable.getName(),nameColumn);
+				Select select = script.insertSelect(c, sourceTable, keyColumnFrom, schema);
+				if (!forSourceKey.getSelectsInsideFor().contains(select)) {
+					forSourceKey.getSelectsInsideFor().add(select);
+				}
+				Column target = mu.findColumn(schema, se, mc.getColTo().getTable(), mc.getColTo().getData());
+				insertTarget.addColumnValue(c, select, keyColumnTo, target);
+			}
+			script.getInserts().add(insertTarget);
+		}		
+		return script;
+	}
+	private void addForSelectInsert(For firstFor, Select s, Insert insert) {
+		this.getFors().add(firstFor);
+		this.getSelects().add(s);
+		this.getInserts().add(insert);	
+	}
+	/**
+	 * Adds a column to be searched in a SELECT statement from a table. If a SELECT does not currently exist, it creates one. Returns the SELECT
+	 * that is either created or found
+	 */
+	private Select insertSelect(Column c, Table from, String[] keyColumnFrom, Schema schema) {
+		Select s = new Select().getSelectTable (this.getSelects(), from.getName());
+		if (s!=null) {
+			log.info("Using existing SELECT to query column :%s",c.getName());
+			s.getSearch().add(c);
+		}
+		else {
+			log.info("New SELECT to query column : %s", c.getName());
+			s = new Select (from, c);
+			s.addWhere (schema, keyColumnFrom);		
+			Select sourceValues = s.getSelectSourceValueWhere(s.getWhere(), selects);
+			if (sourceValues != null) {
+				if (sourceValues.getLoopFor() == null) { 
+					For newFor = new For();
+					newFor.newForSelect(sourceValues);
+					this.getFors().add(newFor);
+				}
+				else {
+					s.setInsideFor(sourceValues.getLoopFor());
+					sourceValues.getLoopFor().getSelectsInsideFor().add(s);
+				}
+			}
+			this.getSelects().add(s);
+		}
+		return s;
+	}
+
+	public boolean inList(Column c, List<ColumnValue> columnValues) {
+		for (ColumnValue cv : columnValues) {
+			if (cv.getColumn().equals(c)) {
+				return true;
+			}
+		}
+		return false;
+	}
+}
diff --git a/modevo-script/src/main/java/giis/modevo/migration/script/ScriptException.java b/modevo-script/src/main/java/giis/modevo/migration/script/ScriptException.java
new file mode 100644
index 0000000..b1ac07e
--- /dev/null
+++ b/modevo-script/src/main/java/giis/modevo/migration/script/ScriptException.java
@@ -0,0 +1,22 @@
+package giis.modevo.migration.script;
+
+public class ScriptException extends RuntimeException {
+
+	private static final long serialVersionUID = 8082461243780187333L;
+	
+	public ScriptException() {
+		super();
+	}
+	public ScriptException(String message, Throwable cause, boolean enableSuppression, boolean writableStackTrace) {
+		super(message, cause, enableSuppression, writableStackTrace);
+	}
+	public ScriptException(String message, Throwable cause) {
+		super(message, cause);
+	}
+	public ScriptException(String message) {
+		super(message);
+	}
+	public ScriptException(Throwable cause) {
+		super(cause);
+	}
+}
diff --git a/modevo-script/src/main/java/giis/modevo/migration/script/ScriptText.java b/modevo-script/src/main/java/giis/modevo/migration/script/ScriptText.java
new file mode 100644
index 0000000..30fdab8
--- /dev/null
+++ b/modevo-script/src/main/java/giis/modevo/migration/script/ScriptText.java
@@ -0,0 +1,139 @@
+package giis.modevo.migration.script;
+
+import java.util.List;
+
+import giis.modevo.model.schema.Column;
+import lombok.extern.slf4j.Slf4j;
+
+@Slf4j
+public class ScriptText {
+	private int counterVariables;
+
+	public ScriptText() {
+		counterVariables = 1;
+	}
+	/**
+	 * Generates and returns the textual description of the script contained in the given parameter
+	 */
+	public String writeScript(Script s) {
+		if (!s.isExecutable()) {
+			log.warn("Not executable script because there are key columns that cannot be inserted");
+			return "Not executable script because there are key columns that cannot be inserted";
+		}
+		StringBuilder sb = new StringBuilder();
+		For forNested = s.getFors().get(0);
+		while (forNested != null) {
+			writeSyntaxFor (sb, forNested, s);
+			forNested = forNested.getNestedFor();
+		}
+		writeSyntaxInsert (sb, s);
+		log.info("Script screated");
+		return sb.toString();
+	}
+	
+	/**
+	 * Writes all the Insert statements inside an script
+	 */
+	private void writeSyntaxInsert(StringBuilder sb, Script s) {
+		List<Insert> insertsLocal = s.getInserts();
+		for (Insert i: insertsLocal) {
+			String nameTable = i.getTable().getName();
+			if (!i.getNameNewTable().isEmpty()) {
+				nameTable = i.getNameNewTable();
+			}
+			StringBuilder insertSB = new StringBuilder("INSERT INTO ").append(nameTable).append("(");
+			StringBuilder namesColumns = new StringBuilder();
+			StringBuilder insertPlaceholders = new StringBuilder();
+			for (int j=0; j<i.getColumnValue().size();j++){
+				if (j>0) {
+					namesColumns.append(", ");
+					insertPlaceholders.append(", ");
+				}
+				ColumnValue cv = i.getColumnValue().get(j);
+				if (cv.getVariableName()==null) {
+					cv.setVariableName(cv.getColumn().getVariableName());
+				}
+				String nameColumn = cv.getColumn().getName();
+				String nameVariable=cv.getSelectOrigin().findNameVariable (cv.getColumn().getNameAttribute(), cv.getColumn().getNameEntity());
+				namesColumns.append(nameColumn);
+				insertPlaceholders.append(nameVariable);
+			}
+			insertSB.append(namesColumns).append(") VALUES (").append(insertPlaceholders).append(");\n");
+			sb.append(insertSB);
+			i.setInsertStatement(insertSB.toString());
+		}
+		
+	}
+	/**
+	 * Writes the syntax for a For loop of the script and the Select statements inside of it
+	 */
+	private void writeSyntaxFor(StringBuilder sb, For forNested, Script se) {
+		sb.append("FOR ");
+		for (int k =0; k<forNested.getSelectsFor().size();k++) {
+			if (k>0) {
+				sb.append(" AND ");
+			}
+			Select s = forNested.getSelectsFor().get(k);
+			buildSelect (s, sb, se);
+		}
+		sb.append("\n");
+		for (Select s : forNested.getSelectsInsideFor()) {
+			buildSelect (s, sb, se);
+			sb.append("\n");
+		}
+	}
+	/**
+	 * Returns the Select statement as a string. It also adds the select to parameter sb with the association of the variable names for the textual script
+	 */
+	private String buildSelect(Select s, StringBuilder sb, Script se) {
+		StringBuilder columns = new StringBuilder("SELECT ");
+		for (int i=0; i<s.getSearch().size();i++) {
+			if (i>0) {
+				columns.append(", ");
+				sb.append(",");
+			}
+			String variableName = "$"+counterVariables;
+			s.getSearch().get(i).setVariableName(variableName);
+			sb.append(variableName);
+			columns.append(s.getSearch().get(i).getName());
+			counterVariables++;
+		}
+		columns.append(" FROM ").append(s.getTable().getName());
+		for (int j=0; j<s.getWhere().size();j++) {
+			if (j==0) {
+				columns.append(" WHERE ");
+			}
+			else {
+				columns.append(" AND ");
+			}
+			Column ce = s.getWhere().get(j);
+			String nameVariable = this.getNameVariableColumn (ce, se);
+			ce.setVariableName(nameVariable);
+
+			columns.append(ce.getName()).append("=").append(nameVariable);
+		}
+		if (!s.getWhere().isEmpty()) {
+			columns.append(" ALLOW FILTERING");
+		}
+		sb.append(" = ").append(columns);
+		s.setSelectStatement(columns.toString());
+		return columns.toString();
+		
+	}
+
+	private String getNameVariableColumn(Column ce, Script s) {
+		String nameAttribute = ce.getNameAttribute();
+		String nameEntity = ce.getNameEntity();
+		for (Select select : s.getSelects()) {
+			for (Column column : select.getSearch()) {
+				String nameAttributeCurrent = column.getNameAttribute();
+				String nameEntityCurrent = column.getNameEntity();
+				if (nameAttribute.equalsIgnoreCase(nameAttributeCurrent) && nameEntity.equalsIgnoreCase(nameEntityCurrent)) {
+					return column.getVariableName(); //check if this can enter and still be null
+				}
+			}
+		}
+		log.warn("No variable name found for column %s", ce.getName());		
+		return null;
+	}
+}
diff --git a/modevo-script/src/main/java/giis/modevo/migration/script/Select.java b/modevo-script/src/main/java/giis/modevo/migration/script/Select.java
new file mode 100644
index 0000000..bb2d027
--- /dev/null
+++ b/modevo-script/src/main/java/giis/modevo/migration/script/Select.java
@@ -0,0 +1,128 @@
+package giis.modevo.migration.script;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import giis.modevo.model.ModelUtilities;
+import giis.modevo.model.schema.Column;
+import giis.modevo.model.schema.Schema;
+import giis.modevo.model.schema.Table;
+import giis.modevo.model.schemaevolution.SchemaEvolution;
+import lombok.Getter;
+import lombok.Setter;
+import lombok.extern.slf4j.Slf4j;
+@Getter @Setter @Slf4j
+public class Select {
+	private List<Column> search;
+	private Table table;
+	private List<ColumnValue> whereValue;
+	private List<Column> where;
+	private String selectStatement;
+	private For insideFor; //when the SELECT is inside a FOR
+	private For loopFor; //when the FOR iterates over the SELECT results
+	
+	public Select () {
+		where = new ArrayList<>();
+		search = new ArrayList<>();
+		whereValue = new ArrayList<>();
+	}
+	
+	public Select(For firstFor) {
+		this();
+		this.setLoopFor(firstFor);
+	}
+
+	public Select(Table table, Column c) {
+		this();
+		this.table = table;
+		search.add(c);
+	}
+
+	public Select(For loopFor, Table table) {
+		this ();
+		this.loopFor = loopFor;
+		this.table = table;
+	}
+	public boolean includesAllColumns(List<Column> where2) {
+		for (Column c: where2) {
+			String nameAttribute = c.getNameAttribute();
+			String nameEntity = c.getNameEntity();
+			if (!columnInSearch(nameEntity, nameAttribute)) {
+				return false;
+			}
+		}
+		return true;
+		
+	}
+	private boolean columnInSearch(String nameEntity, String nameAttribute) {
+		for (Column c: search) {
+			if (c.getNameEntity().equalsIgnoreCase(nameEntity) && c.getNameAttribute().equalsIgnoreCase(nameAttribute)) {
+				return true;
+			}
+		}
+		return false;
+	}
+	public String findNameVariable(String nameAttribute, String nameEntity) {
+		for (Column c: search) {
+			if (c.getNameAttribute().equalsIgnoreCase(nameAttribute) && c.getNameEntity().equalsIgnoreCase(nameEntity)) {
+				return c.getVariableName();
+			}
+		}
+		log.error("No column found for entity %s and attribute %s. There is an inconsistency in the input models", nameEntity, nameAttribute);
+		return null;
+		
+	}
+
+	public Column getColumnSearch(String name) {
+		for (Column c: search) {
+			if (c.getName().equalsIgnoreCase(name)) {
+				return c;
+			}
+		}
+		log.error("No column %s found, there is an inconsistency in the input models", name);
+		return null;
+	}
+
+	public void addColumnSearch(Schema schema, SchemaEvolution se, String nameTable, Column c) {
+		this.getSearch().add(c);
+		if (this.getTable() == null) {
+			this.setTable(new ModelUtilities().findTable(schema, se, nameTable));
+		}
+		
+	}
+
+	public void addWhere(Schema schema, String[] keyColumnFrom) {
+		for (String keyColumn:keyColumnFrom ) {
+			Column cFrom= schema.getColumn(table.getName(), keyColumn);
+			this.getWhere().add(cFrom);
+		}
+		
+	}
+	/**
+	 * Gets the SELECT statement that uses in the Where the columns from the parameter
+	 */
+	public Select getSelectSourceValueWhere(List<Column> where, List<Select> selects) {
+		log.info("Get existing SELECT for columns %s", where.toString());
+		for (Select s: selects) {
+			boolean includesColumns = s.includesAllColumns (where);
+			if (includesColumns) {
+				return s;
+			}
+		}
+		log.info("No SELECT found for columns %s", where.toString());
+		return null;
+		
+	}
+	/**
+	 * Gets the SELECT statement that queries the given table
+	 */
+	public Select getSelectTable(List<Select> selects, String nameTable) {
+		for (Select s: selects) {
+			if (s.getTable().getName().equalsIgnoreCase(nameTable)) {
+				return s;
+			}
+		}
+		log.error("No table found, there is an inconsistency in the input models");
+		return null;
+	}
+}
diff --git a/modevo-script/src/main/java/giis/modevo/migration/script/execution/CassandraConnection.java b/modevo-script/src/main/java/giis/modevo/migration/script/execution/CassandraConnection.java
new file mode 100644
index 0000000..625e062
--- /dev/null
+++ b/modevo-script/src/main/java/giis/modevo/migration/script/execution/CassandraConnection.java
@@ -0,0 +1,39 @@
+package giis.modevo.migration.script.execution;
+
+import com.datastax.driver.core.Cluster;
+import com.datastax.driver.core.ResultSet;
+import com.datastax.driver.core.Session;
+
+import lombok.extern.slf4j.Slf4j;
+@Slf4j
+public class CassandraConnection {
+
+	private Cluster cluster;
+	private Session session;
+	public CassandraConnection(String propertiesPath) {
+		connect(propertiesPath);
+	}
+
+	/**
+	 * Establish the connection to a Cassandra database
+	 */
+	public void connect(String propertiesPath) {
+		ConnectionData dc = new ConnectionData(propertiesPath);
+		String ip=dc.getIp();
+		int port = dc.getPort();
+		String username = dc.getUser();
+		String password = dc.getPassword();
+		cluster = Cluster.builder().withPort(port).addContactPoint(ip).withCredentials(username, password).build();
+		session=cluster.newSession();
+		log.info("Connection with database succesful");
+	}
+
+	public void close() {
+		cluster.close();
+		log.info("Connection with database closed");
+	}
+	public ResultSet executeStatement(String strLine) {
+    	return this.session.execute(strLine);		
+	}
+
+}
diff --git a/modevo-script/src/main/java/giis/modevo/migration/script/execution/ConnectionData.java b/modevo-script/src/main/java/giis/modevo/migration/script/execution/ConnectionData.java
new file mode 100644
index 0000000..d284eba
--- /dev/null
+++ b/modevo-script/src/main/java/giis/modevo/migration/script/execution/ConnectionData.java
@@ -0,0 +1,44 @@
+package giis.modevo.migration.script.execution;
+
+import java.io.FileInputStream;
+import java.io.IOException;
+import java.util.Properties;
+
+import giis.modevo.migration.script.ScriptException;
+import lombok.Getter;
+import lombok.Setter;
+import lombok.extern.slf4j.Slf4j;
+@Getter @Setter @Slf4j
+public class ConnectionData {
+
+	private String user;
+	private String password;
+	private String ip;
+	private int port;
+	
+	public ConnectionData(String propertiesPath) {
+		Properties properties = loadProperties(propertiesPath);
+		ip=properties.getProperty("ip").trim();
+		String portExtracted = properties.getProperty("port").trim();
+		user = properties.getProperty("user").trim();
+		password = properties.getProperty("password").trim();
+		try {
+			port = Integer.valueOf(portExtracted);
+	    } catch(NumberFormatException e) { //If no port is assigned, the default 9042 is assigned
+	    	port = 9042;
+			log.info("Using default port %d", port);
+	    }
+	}
+	private Properties loadProperties(String propertiesPath) {
+		Properties properties = new Properties();
+		FileInputStream in;
+		try {
+			in = new FileInputStream(propertiesPath);
+			properties.load(in);
+			in.close();
+		} catch (IOException e) {
+			throw new ScriptException ("Error opening properties file");
+		}
+		return properties;
+	}
+}
diff --git a/modevo-script/src/main/java/giis/modevo/migration/script/execution/ScriptExecution.java b/modevo-script/src/main/java/giis/modevo/migration/script/execution/ScriptExecution.java
new file mode 100644
index 0000000..043a93b
--- /dev/null
+++ b/modevo-script/src/main/java/giis/modevo/migration/script/execution/ScriptExecution.java
@@ -0,0 +1,128 @@
+package giis.modevo.migration.script.execution;
+
+import java.util.ArrayList;
+import java.util.Iterator;
+import java.util.List;
+
+import com.datastax.driver.core.ColumnDefinitions;
+import com.datastax.driver.core.ResultSet;
+import com.datastax.driver.core.Row;
+import com.datastax.driver.core.ColumnDefinitions.Definition;
+
+import giis.modevo.migration.script.ColumnValue;
+import giis.modevo.migration.script.For;
+import giis.modevo.migration.script.Insert;
+import giis.modevo.migration.script.Script;
+import giis.modevo.migration.script.ScriptException;
+import giis.modevo.migration.script.Select;
+import giis.modevo.model.schema.Column;
+
+public class ScriptExecution {
+	private static final String FROM = "FROM ";
+
+
+	/**
+	 * Main class to initiate the execution of the script
+	 * @param c Object of the open session with the connection establishes to execute the script.
+	 */
+	public void execute(Script script, CassandraConnection c, String nameKeyspace) {
+		if (!script.isExecutable()) {
+			return;
+		}
+		List<For> highLevelFors = script.getForsHigherLevel();
+		for (For highFor : highLevelFors) {
+			List<Select> highLevelSelects = highFor.getSelectsFor();
+			Select s = highLevelSelects.get(0); //For now there is only one select at most, change into a list when there will be more.
+			String nameTable = s.getTable().getName();
+			String selectStatementWithKeyspace = s.getSelectStatement().replace(FROM+nameTable,FROM+ "\""+nameKeyspace+"\"."+nameTable);
+			ResultSet rs = c.executeStatement(selectStatementWithKeyspace);
+			Iterator<Row> resultIt = rs.iterator();
+			while (resultIt.hasNext()) {	
+				Row rw = resultIt.next();
+				List<ColumnValue> cvs = getColumnValuesSearchRow(rw, s);
+				List<Select> selectsInside = highFor.getSelectsInsideFor();
+				executeSelects (cvs, selectsInside, c, nameKeyspace);
+				executeInserts (script, cvs, highFor, c, nameKeyspace);			
+			}
+		}
+	}
+	/**
+	 * Execution of the insert statements inside a FOR loop
+	 */
+	private void executeInserts(Script script, List<ColumnValue> cvs, For highFor, CassandraConnection c, String nameKeyspace) {
+		for (Insert i: script.getInserts()) {
+			if (i.getInsideFor().equals(highFor)){
+				String insertStatement = i.getInsertStatement();
+				for (ColumnValue cv : i.getColumnValue()) {
+					String variableName = cv.getVariableName();
+					if (variableName == null) {
+						variableName = cv.getColumnSelectOrigin().getVariableName();
+					}
+					ColumnValue cvValues = findCVNameVariable (cvs, variableName);
+					if (cvValues == null) {
+						throw new ScriptException ("There has been error, the column "+cv.getColumn().getName()+" did not have a value to insert.");
+					}
+					insertStatement= insertStatement.replace(variableName, "'"+cvValues.getValue()+"'");
+				}
+				String nameTableInsert = i.getNameTable();
+				String statementInsertWithKeyspace = insertStatement.replace("INSERT INTO "+nameTableInsert, "INSERT INTO "+"\""+nameKeyspace+"\"."+nameTableInsert);
+				c.executeStatement(statementInsertWithKeyspace);
+			}
+		}	
+	}
+	/**
+	 * Execution of the Select statements inside a For loop
+	 */
+	private void executeSelects(List<ColumnValue> cvs, List<Select> selectsInside, CassandraConnection c, String nameKeyspace) {
+		for (Select selectInside : selectsInside) {
+			String statementSelect = selectInside.getSelectStatement();
+			selectInside.getWhereValue();
+			
+			for (Column whereValue: selectInside.getWhere()) {
+				String vn = whereValue.getVariableName();
+				ColumnValue cv = findCVNameVariable(cvs, vn);
+				if (cv == null) {
+					throw new ScriptException ("There has been error, the column "+whereValue.getName()+" did not have a value to insert.");
+				}
+				statementSelect=statementSelect.replace(vn, "'"+cv.getValue()+"'");
+			}
+			String nameTableInside = selectInside.getTable().getName();
+			String statementSelectWithKeyspace = statementSelect.replace(FROM+nameTableInside,FROM+ "\""+nameKeyspace+"\"."+nameTableInside);
+			ResultSet rssecond = c.executeStatement(statementSelectWithKeyspace);
+			Iterator<Row> rssecondIt = rssecond.iterator();
+			while (rssecondIt.hasNext()) {
+				Row rws = rssecondIt.next();
+				ColumnDefinitions cd = rws.getColumnDefinitions();
+				for (Definition d : cd.asList()) {
+					ColumnValue cv = new ColumnValue ();
+					Column column = selectInside.getColumnSearch(d.getName());
+					column.setName(d.getName());
+					cv.setColumn(column);
+					cv.setValue(rws.getString(d.getName().trim()));
+					cv.setVariableName(column.getVariableName());
+					cvs.add(cv);
+				}
+			}
+		}
+		
+	}
+	private List<ColumnValue> getColumnValuesSearchRow(Row rw, Select s) {
+		List<ColumnValue> cvs = new ArrayList<>();
+		for (Column c: s.getSearch()) {
+			ColumnValue cv = new ColumnValue ();
+			cv.setColumn(c);
+			cv.setValue(rw.getString(c.getName()));
+			cv.setVariableName(c.getVariableName());
+			cvs.add(cv);
+		}
+		return cvs;
+	}
+	private ColumnValue findCVNameVariable(List<ColumnValue> cvs, String nameVariable) {
+		for (ColumnValue cv : cvs) {
+			if (cv.getVariableName().equalsIgnoreCase(nameVariable)) {
+				return cv;
+			}
+		}
+		return null;
+	}
+}
diff --git a/modevo-script/src/test/java/giis/m2/TestClass2.java b/modevo-script/src/test/java/giis/m2/TestClass2.java
deleted file mode 100644
index 760434d..0000000
--- a/modevo-script/src/test/java/giis/m2/TestClass2.java
+++ /dev/null
@@ -1,27 +0,0 @@
-package giis.m2;
-
-import static org.junit.Assert.assertEquals;
-
-import org.junit.Before;
-import org.junit.Rule;
-import org.junit.Test;
-import org.junit.rules.TestName;
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
-
-public class TestClass2 {
-	private final Logger log=LoggerFactory.getLogger(this.getClass());
-
-	@Rule 
-	public TestName testName = new TestName();
-	
-	@Before
-	public void setUp() {
-		log.info("****** Running test: {} ******", testName.getMethodName());
-	}
-	@Test
-	public void testFunction21() {
-		assertEquals("11-12", new Class2().function21());
-	}
-
-}
diff --git a/modevo-script/src/test/java/test4giis/script/TestExecutionScript.java b/modevo-script/src/test/java/test4giis/script/TestExecutionScript.java
new file mode 100644
index 0000000..c81b413
--- /dev/null
+++ b/modevo-script/src/test/java/test4giis/script/TestExecutionScript.java
@@ -0,0 +1,162 @@
+package test4giis.script;
+
+import java.io.BufferedReader;
+import java.io.FileInputStream;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.nio.file.Paths;
+
+import org.junit.AfterClass;
+import org.junit.Before;
+import org.junit.BeforeClass;
+import org.junit.Rule;
+import org.junit.Test;
+import org.junit.rules.TestName;
+
+import giis.modevo.migration.script.MainScript;
+import giis.modevo.migration.script.execution.CassandraConnection;
+import giis.modevo.model.ModelObjects;
+import test4giis.modevo.TestUtils;
+
+public class TestExecutionScript {
+	private static final String PROPERTIES = "modevo.properties";
+	private static CassandraConnection connection;
+	private static final String bmkPath = "dat/bmk/";
+	private static final String outputPath = "dat/out/";
+	private static final String outputScript=  "script.cql";
+
+	@Rule public TestName name = new TestName();
+	@BeforeClass
+	public static void setUp(){ //cleans the entire DB
+		connection = new CassandraConnection(PROPERTIES);
+	}
+	@AfterClass
+	public static void tearDown(){
+		connection.close();
+	}
+	@Before
+	public void setUpTestCase() {
+		String cql = "dat/inp/db/"+name.getMethodName()+"-initDB.cql";
+		executeCQLFile(cql);
+	}
+	@Test
+	public void testThingsBoardV11NewColumnNonKey() {
+		testScript(name.getMethodName(), connection);	
+	}
+	@Test
+	public void testThingsBoardV12NewColumnPK() {
+		testScript(name.getMethodName(), connection);	
+	}
+	@Test
+	public void testThingsBoardV13NewColumnKeyInTable()  {
+		testScript(name.getMethodName(), connection);	
+	}
+	@Test
+	public void testMindsV9NewTableMigrationFromOneTable () {
+		testScript(name.getMethodName(), connection);	
+	}
+	@Test
+	public void testMindsV9NewColumnsPreviousVersion () {
+		testScript(name.getMethodName(), connection);	
+	}
+	@Test
+	public void testMindsV10NewTableMigrationFromOneTable () {
+		testScript(name.getMethodName(), connection);	
+	}
+	@Test
+	public void testMindsV25NewTableMigrationFromOneTable () {
+		testScript(name.getMethodName(), connection);	
+	}
+	@Test
+	public void testMindsV27NewTableMigrationFromOneTable () {
+		testScript(name.getMethodName(), connection);	
+	}
+	@Test
+	public void testWireV2NewTableMigrationFromOneTable () {
+		testScript(name.getMethodName(), connection);	
+	}
+	@Test
+	public void testWireV8NewTableMigrationFromPreviousVersion () {
+		testScript(name.getMethodName(), connection);	
+	}
+	@Test
+	public void testWireV91NewTableMigrationFromOneTable () {
+		testScript(name.getMethodName(), connection);	
+	}
+	@Test
+	public void testWireV92NewTableMigrationFromSeveralTables () {
+		testScript(name.getMethodName(), connection);	
+	}
+	@Test
+	public void testCustomV1NewColumn () {
+		testScript(name.getMethodName(), connection);	
+	}
+	@Test
+	public void testCustomV2TwoNewColumnSourceTwoTables () {
+		testScript(name.getMethodName(), connection);	
+	}
+	@Test
+	public void testCustomV3TwoNewColumnsUsingNMRelationship () {
+		testScript(name.getMethodName(), connection);	
+	}
+	@Test
+	public void testCustomV4JoinTable () {
+		testScript(name.getMethodName(), connection);	
+	}
+	@Test
+	public void testCustomV5JoinTableKeyEntityInTargetTable () {
+		testScript(name.getMethodName(), connection);	
+	}
+	@Test
+	public void testCustomV6CopyTable () {
+		testScript(name.getMethodName(), connection);	
+	}
+	@Test
+	public void testCustomV7SplitTable () {
+		testScript(name.getMethodName(), connection);	
+	}
+	private static void executeCQLFile(String path){
+	     try{
+	            // Open the file that is the first 
+	            // command line parameter
+	            FileInputStream fstream = new FileInputStream(path);
+	            BufferedReader br = new BufferedReader(new InputStreamReader(fstream));
+	            String strLine;
+	            //Read File Line By Line
+	            while ((strLine = br.readLine()) != null)   {
+		            if (!(strLine.contains("--") || strLine.isBlank())){
+		            	connection.executeStatement (strLine);
+		            }
+	            }
+	            //Close the input stream
+	            fstream.close();
+	     }catch (Exception e){//Catch exception if any
+	            connection.close();
+	  			throw new RuntimeException ("Error executing CQL statement: "+e.getMessage());
+	     } 
+	}
+	private void testScript (String nameTest,  CassandraConnection c) {
+		ModelObjects m = new TestUtils().executeTransformationsAndCompareOutput (nameTest);
+		createExecuteScript (nameTest, m, c);
+	}
+	private void createExecuteScript (String nameTest, ModelObjects m, CassandraConnection c) {
+		String nameTestDash = nameTest +"-";//Added dash to separate nameTest and type of file in the name of the file
+		String script = new MainScript().createScriptAndText(m, c, nameTest);
+		if (script != null) {//until all scenarios have been covered
+			String fullPathScript = outputScriptFile (script, nameTest);
+			new TestUtils().AssertEqualFiles (bmkPath+nameTestDash+outputScript, fullPathScript);	//Introduces the name of the test to the path	
+		}
+	}
+	private String outputScriptFile (String script, String nameTest) {
+		String path = outputPath+nameTest+"-script.cql";
+		Path scriptPath = Paths.get(path);
+		try {
+			Files.write(scriptPath, script.getBytes());
+		} catch (IOException e) {
+			throw new RuntimeException (e);
+		}
+		return path;
+	}	
+}
diff --git a/modevo-transform/src/test/java/test4giis/modevo/TestUtils.java b/modevo-transform/src/test/java/test4giis/modevo/TestUtils.java
index c9f4b31..4aeff0c 100644
--- a/modevo-transform/src/test/java/test4giis/modevo/TestUtils.java
+++ b/modevo-transform/src/test/java/test4giis/modevo/TestUtils.java
@@ -33,7 +33,7 @@ protected void testModels (String nameTest) {
 	/**
 	 * Prepares the inputs for the model transformation and checks if the output is the expected one.
 	 */
-	protected ModelObjects executeTransformationsAndCompareOutput(String nameTest) {
+	public ModelObjects executeTransformationsAndCompareOutput(String nameTest) {
 		String nameTestDash = nameTest +"-";//Added dash to separate nameTest and type of file in the name of the file
 		String outputTest = outputPath+nameTestDash+output;
 		Pattern pattern = Pattern.compile("(?<=test).*(?=V[0-9])");
@@ -72,7 +72,7 @@ private void copyInputs(String schemaInp, String cmInp, String schemaEvolutionIn
 	/**
 	 * Compares the content of the files whose paths are specified in the method's parameter. 
 	 */
-	protected void AssertEqualFiles (String outputBMK, String outputTest) {
+	public void AssertEqualFiles (String outputBMK, String outputTest) {
 		Path outputTestPath = Paths.get(outputTest);
 		Path outputBMKPath = Paths.get(outputBMK);
 		try {