[vc_row][vc_column][masterslider_pb alias=”home”][/vc_column][/vc_row][vc_row][vc_column][vc_column_text]

OKHOSTING.ORM

Indice

• 1.- Introduccion
• 2.- Instalación
• 3.- Documentacion tecnica
• 4.- Requerimientos
• 5.- Identificar nuestro escenario
  • 5.1 Escenario 1, sin base de datos ni clases
  • 5.2 Escenario 2, con clases pero sin base de datos
  • 5.3 Escenario 3, con base de datos pero sin clases
  • 5.4 Escenario 4, con base de datos y con clases
• 6.- Eliminar tablas de la base de datos
• 7.- Insertar datos en una tabla
• 8.- Actualizar datos en una tabla
• 9.- Consultas a una tabla de la base de datos
• 10.- Consultas de varios registros a una tabla de la base de datos
• 11.- Consultas a varias tablas de la base de datos (Join)
• 12.- OrderBy

[/vc_column_text][/vc_column][/vc_row][vc_row el_id=”introduccion” css=”.vc_custom_1464127946358{padding-top: 110px !important;}”][vc_column][vc_column_text]

1.- Introducción

OKHOSTING.ORM es un proyecto open source multiplataforma, flexible,  simple, con función completa y funciona con múltiples bases de datos. Funciona con cualquier clase,
cualquier convención de nombres y las bases de datos más utilizadas.

El proyecto OKHOSTING.ORM nos permite crear, editar o borrar tablas en una base de datos, al igual que insertar, editar o borrar datos de la base de datos en la que estés trabajando.

El proyecto implementado en aplicaciones para móvil, solo soporta los motores de base de datos de MySql y sqlite, pero al implementarlo en plataformas de escritorio como sería,
Windows, Linux, Mac, etc, soporta, MySql, SQLite, SQL server y PostgreSQL.

Es compatible con cualquier estrategia de herencia que desee, y cualquier relación de uno a muchos y muchos a muchos que necesite.

OKHOSTINH.ORM esta desarrollado utilizando C# y funciona en Windows, Linux, Mac, Android, iOS, Windows Phone y la plataforma universal de Windows.[/vc_column_text][/vc_column][/vc_row][vc_row el_id=”install” css=”.vc_custom_1464189504461{padding-top: 110px !important;}”][vc_column][vc_column_text]

2.- Instalacción

Para poder utilizar el proyecto OKHOSTING.ORM basta con descargar los paquetes nuget OKHOSTING.ORM y OKHOSTING.ORM.UI e instalarlos.

PM> Install-Package OKHOSTING.ORM
PM> Install-Package OKHOSTING.ORM.UI

• Download OKHOSTING.ORM on NuGet
• Download OKHOSTING.ORM.UI on NuGet

[/vc_column_text][/vc_column][/vc_row][vc_row el_id=”doc” css=”.vc_custom_1464128019159{padding-top: 110px !important;}”][vc_column][vc_column_text]

3.- Documentación tecnica

Para su mejor comprención, en esta sección, podrás consultar la documentación técnica de todo el proyecto OKHOSTING.ORM.

• OKHOSTING.ORM

[/vc_column_text][/vc_column][/vc_row][vc_row el_id=”requerimientos” css=”.vc_custom_1464128029928{padding-top: 110px !important;}”][vc_column][vc_column_text]

4.- Requerimientos

Antes de comenzar a utilizar el proyecto OKHOSTING.ORM debe de tener conocimientos básicos de C# y manejar también las sentencias básicas de sql, ya que éste es el lenguaje
en el que trabajan las bases de datos mencionadas anteriormente.[/vc_column_text][/vc_column][/vc_row][vc_row el_id=”identificar” css=”.vc_custom_1464128038417{padding-top: 110px !important;}”][vc_column][vc_column_text]

5.- Identificar nuestro escenario

Cuando usemos el proyecto OKHOSTING.ORM lo primero que tenemos que hacer es identificar nuestro escenario ya que para poder comenzar tenemos que tener nuestras clases
creadas y nuestra base de datos a la que mapearemos dichas clases, para después poder realizar las operaciones que queramos sobre la base de datos.[/vc_column_text][/vc_column][/vc_row][vc_row el_id=”escenario1″ css=”.vc_custom_1464128047118{padding-top: 110px !important;}”][vc_column][vc_column_text]

5.1 Escenario 1, sin base de datos ni clases

Este escenario se da cuando no contamos con una base de datos ni con las clases que usaremos, en este caso tendremos que crear nuestro modelo de clases y también nuestra
base de datos a la que asignaremos nuestras clases, para crear nuestro modelo de clases, la declaración de las clases seria algo así como en los siguientes ejemplos:

Clase Person

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace OKHOSTING.ORM.Tests.Model
{
	public class Person
	{
		public int Id;

		[OKHOSTING.Data.Validation.StringLengthValidator(100)]
		public string Firstname;

		[OKHOSTING.Data.Validation.StringLengthValidator(100)]
		public string LastName;

		public DateTime BirthDate { get; set; }

		public Address Address1 { get; set; }
		public Address Address2 { get; set; }

		public string FullName
		{
			get
			{
				return Firstname + " " + LastName;
			}
		}
	}
}

Clase Customer

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace OKHOSTING.ORM.Tests.Model
{
	public class Customer
	{
		public int Id;

		[OKHOSTING.Data.Validation.StringLengthValidator(100)]
		public string LegalName { get; set; }

		[OKHOSTING.Data.Validation.StringLengthValidator(100)]
		public string Phone { get; set; }

		public string Email { get; set; }
	}
}

Clase CustomerContact

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace OKHOSTING.ORM.Tests.Model
{
	public class CustomerContact: Person
	{
		public Customer Customer;
	}
}

Así de esta manera tan fasil es como iremos creando las clases que vallamos a utilizar simplemente declarando sus propiedades o en dicho caso indicando si hereda de otra clase,
como en este último ejemplo donde CustomerContact hereda de Person:

public class CustomerContact: Person

Una vez que tengamos creado nuestro modelo de clases y la base de datos, entonces si comenzamos con la construcción de nuestro proyecto, donde lo primero que tenemos que
hacer es establecer la conexión con la base de datos, lo cual hacemos de una manera muy simple:

using System;

using System.Linq;
using System.Collections.Generic;
using OKHOSTING.ORM.Operations;
using OKHOSTING.ORM.Tests.Model;
using Microsoft.VisualStudio.TestTools.UnitTesting;
using OKHOSTING.Sql.Schema;

namespace OKHOSTING.ORM.Tests
{
	[TestClass]
	public class BasicTests
	{
		DataBase DataBase;

		public BasicTests()
		{
			DataBase = new DataBase(new Sql.Net4.MySql.DataBase() { ConnectionString = System.Configuration.ConfigurationManager.ConnectionStrings["Prueba"].ConnectionString }, new Sql.MySql.SqlGenerator());
		}

De esta manera agregamos un método donde obtendremos la conexión a la base de datos, en este caso nuestro método se llama “BasicTest” y con solo una línea podemos obtener
la conexión a una base de datos de MySql, indicándole que de la variable “Pruebas” que se encuentra en el archivo de configuración, es de donde va a obtener la cadena de
conexión.

		public void MapTypes()
		{ 
			var types = new Type[] 
        		{ 
             			typeof(Person), 
	                	typeof(Employee), 
            			typeof(Customer), 
	          		typeof(CustomerContact), 
            			typeof(Address), 
            			typeof(Country) 
        		};

    			var dtypes = DataType.DefaultMap(types).ToList();
		}

Que esta seria la manera más fácil de hacer nuestro mapeo, declarando nuestra lista de clases y después mapeándolas con el método DefaultMap, creando las tablas con el mismo
nombre de las clases, de igual manera, creara todas sus columnas con el mismo nombre de las propiedades de cada clase.

Las propiedades denominadas “Id” (no caseSensitiv) son automáticamente consideradas llaves primarias en este escenario.

En caso de que queramos personalizar el nombre de las tablas, tendríamos que hacer algo tan fácil como este ejemplo:

		foreach (var dtype in dtypes)
		{
    			dtype.Table.Name = "test_" + dtype.Table.Name;
		}

Ya después de tener el mapeo de nuestro modelo de clases a la base de datos, continuamos con la creación de las tablas, para lo cual después del método de mapeo, agregamos un
método donde crearemos las tablas de las clases que tenemos, como se muestra a continuación:

		public void Create()
		{	
			DataBase.Create<Country>();
			DataBase.Create<Address>();
			DataBase.Create<Person>();
			DataBase.Create<Employee>();
			DataBase.Create<Customer>();
			DataBase.Create<CustomerContact>();

			Assert.IsTrue(DataBase.NativeDataBase.ExistsTable("test_Person"));
			Assert.IsTrue(DataBase.NativeDataBase.ExistsTable("test_Employee"));
			Assert.IsTrue(DataBase.NativeDataBase.ExistsTable("test_Customer"));
			Assert.IsTrue(DataBase.NativeDataBase.ExistsTable("test_CustomerContact"));
			Assert.IsTrue(DataBase.NativeDataBase.ExistsTable("test_Address"));
			Assert.IsTrue(DataBase.NativeDataBase.ExistsTable("test_Country"));
		}

Ya cuando tenemos creadas nuestras clases, entonces si ya podemos continuar realizando cualquier operación en la base de datos, ya sea Eliminar tablas,
Insertar datos en una tabla, Actualizar datos a una tabla, Consultar datos de una tabla, etc.[/vc_column_text][/vc_column][/vc_row][vc_row el_id=”escenario2″ css=”.vc_custom_1464128059610{padding-top: 110px !important;}”][vc_column][vc_column_text]

5.2 Escenario 2, con clase pero sin base de datos

Este escenario se presenta cuando ya tenemos nuestro modelo de clases pero no tenemos una base de datos, así que tendríamos que generar nuestro propio esquema de base de
datos para después continuar con el mapeo de las clases, una vez que ya tenemos creada nuestra base de datos, lo primero que tenemos que hacer ya en nuestro proyecto sería,
establecer la conexión a la base de datos, para esto el proyecto OKHOSTING.ORM nos permite hacerlo de una manera muy fásil:

using System;

using System.Linq;
using System.Collections.Generic;
using OKHOSTING.ORM.Operations;
using OKHOSTING.ORM.Tests.Model;
using Microsoft.VisualStudio.TestTools.UnitTesting;
using OKHOSTING.Sql.Schema;

namespace OKHOSTING.ORM.Tests
{
	[TestClass]
	public class BasicTests
	{
		DataBase DataBase;

		public BasicTests()
		{
			DataBase = new DataBase(new Sql.Net4.MySql.DataBase() { ConnectionString = System.Configuration.ConfigurationManager.ConnectionStrings["Prueba"].ConnectionString }, new Sql.MySql.SqlGenerator());
		}

Lo unico que hacemos para esta parte es dentro de nuestro proyecto, dentro del método “BasicTest” con una sola línea de código obtenemos la conexión a una base de datos de
MySQL, indicándole que por medio de la variable “Pruebas” que se encuentra en nuestro archivo de configuración, es donde va a obtener la cadena de conexión.

Después lo que haremos será realizar nuestro mapeo que en este caso tendría que ser un mapeo manual, de esta manera, podemos hacer un mapeo más personalizado como en
este ejemplo:

		[TestMethod]
		public void ManualMapWithTables()
		{
    			Table personTable = new Table("personTable");
	    		personTable.Columns.Add(new Column() { IsPrimaryKey = true, Name = "key", DbType = Sql.DbType.Int32 });
	    		personTable.Columns.Add(new Column() { Name = "name", DbType = Sql.DbType.String });
	    		personTable.Columns.Add(new Column() { Name = "birth", DbType = Sql.DbType.DateTime });

	    		DataType<Person> dtype = new DataType<Person>(personTable);
	    		DataType.AllDataTypes.Add(dtype);
	    		dtype.AddMember(m => m.Id, personTable["key"]);
	    		dtype.AddMember(m => m.Firstname, personTable["name"]);
	    		dtype.AddMember(x => x.BirthDate, personTable["birth"]);

	    		DataType<CustomerContact> dtype2 = new DataType<CustomerContact>();
	    		DataType.AllDataTypes.Add(dtype2);
	    		dtype2.AddMember(m => m.Id);
	    		dtype2.AddMember(m => m.Customer.Id);
	    		dtype2.AddMember(m => m.Customer.LegalName);
	    		dtype2.AddMember(m => m.Customer.Phone);
	    		DataBase.Create<CustomerContact>();

		}

De esta manera ya estamos indicando los tipos de datos de las columnas y especificando que columna es la llave primaria, también por medio de este mapeo, nos permite asignarle
el nombre que nosotros queramos a las columnas y en esta línea:

DataBase.Create<CustomerContact>();

es donde creamos nuestra tabla, que esto seria solo en el caso de que aún no este creada la tabla, de lo contrario tendríamos que omitir esta línea.

Ya cuando tenemos nuestras clases mapeadas a la base de datos y creadas nuestras tablas, entonces si ya podemos continuar realizando cualquier operación en la base de datos
ya sea Eliminar tablas, Realizar consultas de varios registros, Actualizar datos a una tabla, etc.[/vc_column_text][/vc_column][/vc_row][vc_row el_id=”escenario3″ css=”.vc_custom_1464128070784{padding-top: 110px !important;}”][vc_column][vc_column_text]

5.3- Escenario 3, con base de datos pero sin clases

Para este escenario, contamos con una base de datos, pero no contamos con un modelo de clases, así que en este caso tendremos que crear nuestro modelo de clases lo mas
Parecido a las tablas de la base de datos para que al momento de hacer el mapeo, no tengamos ningún problema, las definiciones de las clases lo pueden hacer tan fasil
como los siguientes ejemplos:

Clase Person

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace OKHOSTING.ORM.Tests.Model
{
	public class Person
	{
		public int Id;

		[OKHOSTING.Data.Validation.StringLengthValidator(100)]
		public string Firstname;

		[OKHOSTING.Data.Validation.StringLengthValidator(100)]
		public string LastName;

		public DateTime BirthDate { get; set; }

		public Address Address1 { get; set; }
		public Address Address2 { get; set; }

		public string FullName
		{
			get
			{
				return Firstname + " " + LastName;
			}
		}
	}
}

Clase Employee

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace OKHOSTING.ORM.Tests.Model
{
	public class Employee: Person
	{
		public decimal Salary;
	}
}

Que en éste segundo ejemplo con la línea:

public class Employee: Person

lo que hacemos es indicar que Employee hereda de Person.

Una vez que tengamos nuestras clases y nuestra base de datos, entonces ya procedemos a crear nuestro proyecto, para lo cual, lo primero que ocupamos es establecer la
conexión a la base de datos, lo cual es muy simple de hacer:

using System;

using System.Linq;
using System.Collections.Generic;
using OKHOSTING.ORM.Operations;
using OKHOSTING.ORM.Tests.Model;
using Microsoft.VisualStudio.TestTools.UnitTesting;
using OKHOSTING.Sql.Schema;

namespace OKHOSTING.ORM.Tests
{
	[TestClass]
	public class BasicTests
	{
		DataBase DataBase;

		public BasicTests()
		{
			DataBase = new DataBase(new Sql.Net4.MySql.DataBase() { ConnectionString = System.Configuration.ConfigurationManager.ConnectionStrings["Prueba"].ConnectionString }, new Sql.MySql.SqlGenerator());
		}

Dentro de nuestra clase principal, declaramos un método que en este caso es “BasicTest()” y dentro de el con una sola línea de código, le indicamos que en la variable “Prueba”
que se encuentra en nuestro archivo de configuración, es donde obtendremos la cadena de conexión.

A continuación, lo que hacemos es, realizar el mapeo de nuestras clases a la base de datos, que en este caso lo podemos hacer por medio del mapeo default (DefaultMap) o
realizando un mapeo manual, que nos permite realizar un mapeo más personalizado, ejemplo de mapeo default:

  		public void MapTypes()
		{
			var types = new Type[] 
				{ 
					typeof(Person), 
					typeof(Employee), 
					typeof(Customer), 
					typeof(CustomerContact), 
					typeof(Address), 
					typeof(Country) 
				};

			var dtypes = DataType.DefaultMap(types).ToList();
    		}

Ejemplo de mapeo manual:

		[TestMethod]
		public void ManualMapWithTables()
		{
			Table personTable = new Table("personTable");
			personTable.Columns.Add(new Column() { IsPrimaryKey = true, Name = "key", DbType = Sql.DbType.Int32 });
			personTable.Columns.Add(new Column() { Name = "name", DbType = Sql.DbType.String });
			personTable.Columns.Add(new Column() { Name = "birth", DbType = Sql.DbType.DateTime });

			DataType dtype = new DataType(personTable);
			DataType.AllDataTypes.Add(dtype);
			dtype.AddMember(m => m.Id, personTable["key"]);
			dtype.AddMember(m => m.Firstname, personTable["name"]);
			dtype.AddMember(x => x.BirthDate, personTable["birth"]);

			DataType dtype2 = new DataType();
			DataType.AllDataTypes.Add(dtype2);
			dtype2.AddMember(m => m.Id);
			dtype2.AddMember(m => m.Customer.Id);
			dtype2.AddMember(m => m.Customer.LegalName);
			dtype2.AddMember(m => m.Customer.Phone);
			DataBase.Create();

		}

Que en el caso de realizar un mapeo manual, después continuamos con la creación de nuestras tablas, haciendo esto tan sencillo como el siguiente ejemplo:

		public void Create()
		{
			DataBase.Create<Country>();
			DataBase.Create<Address>();
			DataBase.Create<Person>();
			DataBase.Create<Employee>();
			DataBase.Create<Customer>();
			DataBase.Create<CustomerContact>();

			Assert.IsTrue(DataBase.NativeDataBase.ExistsTable("test_Person"));
			Assert.IsTrue(DataBase.NativeDataBase.ExistsTable("test_Employee"));
			Assert.IsTrue(DataBase.NativeDataBase.ExistsTable("test_Customer"));
			Assert.IsTrue(DataBase.NativeDataBase.ExistsTable("test_CustomerContact"));
			Assert.IsTrue(DataBase.NativeDataBase.ExistsTable("test_Address"));
			Assert.IsTrue(DataBase.NativeDataBase.ExistsTable("test_Country"));
		}

Que en este caso se crean las tablas con el mismo nombre de las clases y sus columnas con el mismo nombre de las propiedades de cada clase, en el caso de realizar un mapeo
manual, ahí mismo estamos creando las tablas si es que aún no están creadas, dándonos la libertad de crear tablas más personalizadas.

Una vez que ya tengamos mapeadas nuestras clases a la base de datos y creadas nuestras tablas, entonces si ya podemos proceder a realizar cualquier operación en la base de
datos como por ejemplo, Insertar datos en una tabla, Seleccionar datos de una tabla, Eliminar tablas, etc.[/vc_column_text][/vc_column][/vc_row][vc_row el_id=”escenario4″ css=”.vc_custom_1464128082669{padding-top: 110px !important;}”][vc_column][vc_column_text]

5.4 Escenario 4, con base de datos y con clases.

Este escenario es cuando ya contamos con la base de datos y con nuestro modelo de clases, en este caso procedemos ya a crear nuestro proyecto, donde lo primero que hacemos
es dentro de nuestra clase principal, con un método que en este caso le llamaremos “BasicTest”, establecer la conexión a la base de datos que esto lo hacemos tan simple
como esto:

using System;

using System.Linq;
using System.Collections.Generic;
using OKHOSTING.ORM.Operations;
using OKHOSTING.ORM.Tests.Model;
using Microsoft.VisualStudio.TestTools.UnitTesting;
using OKHOSTING.Sql.Schema;

namespace OKHOSTING.ORM.Tests
{
	[TestClass]
	public class BasicTests
	{
		DataBase DataBase;

		public BasicTests()
		{
			DataBase = new DataBase(new Sql.Net4.MySql.DataBase() { ConnectionString = System.Configuration.ConfigurationManager.ConnectionStrings["Prueba"].ConnectionString }, new Sql.MySql.SqlGenerator());
		}

Después continuamos con el mapeo de las clases a la base de datos, que en este caso al igual que en el escenario anterior, lo podemos hacer por medio del mapeo default
“DefaultMap” o realizando un mapeo manual, este es un ejemplo del mapeo default:

		public void MapTypes()
		{
			var types = new Type[] 
				{ 
					typeof(Person), 
					typeof(Employee), 
					typeof(Customer), 
					typeof(CustomerContact), 
					typeof(Address), 
					typeof(Country) 
				};

			var dtypes = DataType.DefaultMap(types).ToList();
		}

Y éste es un ejemplo de mapeo manual:

		[TestMethod]
		public void ManualMapWithTables()
		{
			Table personTable = new Table("personTable");
			personTable.Columns.Add(new Column() { IsPrimaryKey = true, Name = "key", DbType = Sql.DbType.Int32 });
			personTable.Columns.Add(new Column() { Name = "name", DbType = Sql.DbType.String });
			personTable.Columns.Add(new Column() { Name = "birth", DbType = Sql.DbType.DateTime });

			DataType dtype = new DataType(personTable);
			DataType.AllDataTypes.Add(dtype);
			dtype.AddMember(m => m.Id, personTable["key"]);
			dtype.AddMember(m => m.Firstname, personTable["name"]);
			dtype.AddMember(x => x.BirthDate, personTable["birth"]);

			DataType dtype2 = new DataType();
			DataType.AllDataTypes.Add(dtype2);
			dtype2.AddMember(m => m.Id);
			dtype2.AddMember(m => m.Customer.Id);
			dtype2.AddMember(m => m.Customer.LegalName);
			dtype2.AddMember(m => m.Customer.Phone);
			DataBase.Create();
		}

En caso de que hayamos hecho un mapeo por medio del método DefaultMap, lo que tenemos que hacer a continuación es la creación de nuestras tablas, para eso hacemos algo tan
sencillo como este ejemplo:

public void Create()
		{
			DataBase.Create<Country>();
			DataBase.Create<Address>();
			DataBase.Create<Person>();
			DataBase.Create<Employee>();
			DataBase.Create<Customer>();
			DataBase.Create<CustomerContact>();

			Assert.IsTrue(DataBase.NativeDataBase.ExistsTable("test_Person"));
			Assert.IsTrue(DataBase.NativeDataBase.ExistsTable("test_Employee"));
			Assert.IsTrue(DataBase.NativeDataBase.ExistsTable("test_Customer"));
			Assert.IsTrue(DataBase.NativeDataBase.ExistsTable("test_CustomerContact"));
			Assert.IsTrue(DataBase.NativeDataBase.ExistsTable("test_Address"));
			Assert.IsTrue(DataBase.NativeDataBase.ExistsTable("test_Country"));
		}

en este caso, lo que hacemos es crear las tablas con el mismo nombre de las tablas y sus columnas con el mismo nombre de las propiedades de las clases, en el caso de que
hayamos hecho un mapeo manual, en ese mismo método creamos las tablas en caso de que aún no tengamos las tablas creadas, dándonos la libertad de crear tablas mas
personalizadas.

Una vez que tengamos ya mapeadas las clases a la base de datos y creadas las tablas, entonces si podemos continuar realizando cualquier operación sobre la base de datos, ya
sea Insertar datos en una tabla, Seleccionar datos de varias tablas, Eliminar tablas, etc.[/vc_column_text][/vc_column][/vc_row][vc_row el_id=”drop” css=”.vc_custom_1464128093161{padding-top: 110px !important;}”][vc_column][vc_column_text]

6.- Eliminar tablas

El proyecto OKHOSTING.ORM también nos permite de una manera muy sencilla eliminar tablas, basta con agregar la sentencia “drop” y especificar que tablas son las que
queremos eliminar como en el siguiente ejemplo:

public void Drop()
{
    DataBase.Drop<CustomerContact>();
    DataBase.Drop<Customer>();
    DataBase.Drop<Employee>();
    DataBase.Drop<Person>();
    DataBase.Drop<Address>();
    DataBase.Drop<Country>();

    Assert.IsFalse(DataBase.NativeDataBase.ExistsTable("test_Person"));
    Assert.IsFalse(DataBase.NativeDataBase.ExistsTable("test_Employee"));
    Assert.IsFalse(DataBase.NativeDataBase.ExistsTable("test_Customer"));
    Assert.IsFalse(DataBase.NativeDataBase.ExistsTable("test_CustomerContact"));
    Assert.IsFalse(DataBase.NativeDataBase.ExistsTable("test_Address"));
    Assert.IsFalse(DataBase.NativeDataBase.ExistsTable("test_Country"));
}

De esta manera, borramos todas las tablas que habíamos creado anteriormente pero también podemos borrar solo una tabla o las que queramos simplemente especificando que
tabla o tablas son las que queremos borrar por ejemplo:

    DataBase.Drop<CustomerContact>();
    DataBase.Drop<Customer>();

[/vc_column_text][/vc_column][/vc_row][vc_row el_id=”insert” css=”.vc_custom_1464128102628{padding-top: 110px !important;}”][vc_column][vc_column_text]

7.- Insertar datos en una tabla

La manera de insertar datos a una tabla en OKHOSTING.ORM es muy sencilla, basta con indicar la tabla a la que se insertarán los datos y en que columna ira cada dato así
como se muestra en el siguiente ejemplo:

[TestMethod]
public void InsertTest()
{
    MapTypes();
    Create();

    Employee employee = new Employee();
    employee.Firstname = "Susana";
    employee.LastName = "Mendoza";
    employee.BirthDate = new DateTime(1980, 1, 1);
    employee.Salary = 1000;
    DataBase.Insert(employee);

    Drop();
}

[/vc_column_text][/vc_column][/vc_row][vc_row el_id=”update” css=”.vc_custom_1464128113340{padding-top: 110px !important;}”][vc_column][vc_column_text]

8.- Actualizar datos a una tabla

Al igual que el insert en el proyecto OKHOSTING.ORM, la manera de actualizar datos en la base de datos también es muy sencilla, basta con especificar la tabla a la que le
vamos a actualizar los datos e indicar en que columna ira cada dato y listo, así como en el siguiente ejemplo:

[TestMethod]
public void Update()
{
    MapTypes();
    Create();

    Employee employee = new Employee();
    employee.Firstname = "Susana";
    employee.LastName = "Mendoza";
    employee.BirthDate = new DateTime(1980, 1, 1);
    employee.Salary = 1000;
    DataBase.Insert(employee);

    employee.Salary = 3000;
    employee.BirthDate = new DateTime(2000, 1, 1);
    DataBase.Update(employee);

    Drop();
}

En este caso primero insertamos datos en las columnas de la tabla, luego indicamos los nuevos datos de las columnas que queremos actualizar y por último solo actualizamos la
tabla con la sentencia “Update” y pasándole entre paréntesis el nombre de la tabla y listo.[/vc_column_text][/vc_column][/vc_row][vc_row el_id=”select” css=”.vc_custom_1464128123923{padding-top: 110px !important;}”][vc_column][vc_column_text]

9.- Consultas a una tabla de la base de datos

Para realizar un select simple en el proyecto OKHOSTING.ORM, es igual de fasil que las operaciones anteriores, seria solamente con la sentencia select e indicándole el
objeto que queremos seleccionar, cabe mencionar que si no le indicamos que columnas queremos seleccionar, lo que hace es seleccionar todas las columnas de esta tabla,
como en el siguiente ejemplo.

[TestMethod]
public void SelectTest()
{
    MapTypes();
    Create();

    Employee employee = new Employee();
    employee.Firstname = "Susana";
    employee.LastName = "Mendoza";
    employee.BirthDate = new DateTime(1980, 1, 1);
    employee.Salary = 1000;
    DataBase.Insert(employee);
    int generatedId = employee.Id;

    employee = new Employee();
    employee.Id = generatedId;

    DataBase.Select(employee);

    Assert.AreEqual("Mendoza", employee.LastName);

    Drop();
}

En este ejemplo lo que también hacemos es pasarle el id del objeto y esto lo toma como un filtro para realizar el select del objeto que contenga este id, seleccionando todas las
columnas de este objeto como lo mencionaba anteriormente.[/vc_column_text][/vc_column][/vc_row][vc_row el_id=”select2″ css=”.vc_custom_1464128133593{padding-top: 110px !important;}”][vc_column][vc_column_text]

10.- Consulta de varios registros a una tabla de la base de datos

El proyecto <b>OKHOSTING.ORM</b> también nos permite realizar selects de varios registros también de una manera muy sencilla, basta con insertar los registros que queremos
selccionar si es que aún no están insertados en la tabla y después agregar la sentencia select indicándole el objeto que queremos seleccionar, como en el siguiente ejemplo:

[TestMethod]
public void BigSelect()
{
    MapTypes();
    Create();

    for (int i = 0; i < 5000; i++)
    {
        CustomerContact contact = new CustomerContact();

        contact.Customer = new Customer();
        contact.Customer.LegalName = "Empresa " + i;
        contact.Customer.Phone = i.ToString();
        contact.Customer.Email= "empres@a.com" + i;
        DataBase.Insert(contact.Customer);

        contact.Firstname = "Argentina " + i;
        contact.LastName = "Chichona";
        contact.BirthDate = new DateTime(1980, 1, 1).AddDays(i);
        DataBase.Insert(contact);
    }

    foreach (var e in DataBase.Select<CustomerContact>())
    {
        Console.WriteLine(e.Id + " " + e.Firstname);
    }

    Drop();
}

En este caso lo que hacemos al final es, para cada registro seleccionado, imprimir en consola, las columnas de Id y Firstname.[/vc_column_text][/vc_column][/vc_row][vc_row el_id=”join” css=”.vc_custom_1464128143796{padding-top: 110px !important;}”][vc_column][vc_column_text]

11.- Consultas a varias tablas de la base de datos (Join)

El proyecto OKHOSTING.ORM también nos permite seleccionar datos de diferentes tablas con la sentencia Join, en este caso hay dos maneras de hacerlo, la primera
seria como en el siguiente ejemplo que seria la más recomendable por ser más sencilla:

Select<CustomerContact> select = new Select<CustomerContact>();
select.AddMembers
(
    c => c.Id, 
    c => c.BirthDate, 
    c => c.Customer.LegalName, 
    c => c.Address1.Street, 
    c => c.Address1.Country.Name,
    c => c.Address2.Street,
    c => c.Address2.Country.Name,
    c => c.Customer.Phone
);

var dtype = DataType<CustomerContact>.GetMap();
select.Where.Add(new Filters.ValueCompareFilter()
{
    Member = dtype[x => x.Id],
    ValueToCompare = 3,
    Operator = Data.CompareOperator.LessThanEqual,
});

select.OrderBy.Add(new Operations.OrderBy() { Member = dtype[x => x.Id], Direction = Data.SortDirection.Descending });

var result = DataBase.Select<CustomerContact>(select).ToList();

Que en este caso solo le indicamos las columnas que queremos seleccionar y ya el proyecto solo hace los joins a las otras tablas de las que necesita tomar datos y en
la siguiente linea:

select.OrderBy.Add(new Operations.OrderBy() { Member = dtype[x => x.Id], Direction = Data.SortDirection.Descending });

lo que hacemos es indicarle que ordene los datos por medio de la columna Id y en orden descendente.

La otra manera de seleccionar datos de varias tablas es como en el siguiente ejemplo:

[TestMethod]
public void ComplexSelect()
{
    MapTypes();
    Create();

    for (int i = 0; i < 20; i++)
    {
        CustomerContact contact = new CustomerContact();

        contact.Customer = new Customer();
        contact.Customer.LegalName = "Empresa " + i;
        contact.Customer.Phone = i.ToString();
        contact.Customer.Email = "empres@a.com" + i;
        DataBase.Table<int, Customer>().Add(new KeyValuePair<int, Customer>(0, contact.Customer));

        contact.Firstname = "Argentina " + i;
        contact.LastName = "Chichona";
        contact.BirthDate = new DateTime(1980, 1, 1).AddDays(i);
        DataBase.Table<int, CustomerContact>().Add(new KeyValuePair<int, CustomerContact>(0, contact));
    }

    Select<CustomerContact> select = new Select<CustomerContact>();

    foreach (var member in select.DataType.DataMembers)
    {
        select.Members.Add(new Operations.SelectMember(member));
    }

    SelectJoin join = new SelectJoin();
    join.JoinType = SelectJoinType.Inner;
    join.Type = typeof(Customer);
    join.On.Add(new Filters.MemberCompareFilter(){ Member = select.DataType["Customer.Id"], MemberToCompare = join.Type["id"], Operator = Data.CompareOperator.Equal });
    select.Joins.Add(join);

    foreach (var member in join.Type.DataMembers.Where(m=> !m.Column.IsPrimaryKey))
    {
        select.Members.Add(new Operations.SelectMember(member));
    }

    foreach (CustomerContact e in DataBase.Select(select))
    {
        Console.WriteLine(e.Firstname + " " + e.Customer.LegalName);
    }

    Drop();
}

En este caso lo que hacemos es primero hacer un select a una tabla y después en la sentencia Join le indicamos a que otra tabla hacer la unión para tomar los datos que
ocupamos, como se muestra a continuación:

join.Type = typeof(Customer);

y con la siguiente linea le indicamos que filtre los datos por las columnas de Id de ambas tablas, de tal manera que comparamos los Id de cada tabla para verificar que sean
iguales y no tomar datos erroneos:

join.On.Add(new Filters.MemberCompareFilter(){ Member = select.DataType["Customer.Id"], MemberToCompare = join.Type["id"], Operator = Data.CompareOperator.Equal });

Por lo que cabe mencionar que la manera más recomendada de realisar selección de datos de varias tablas, seria por medio del primer ejemplo, ya que es más sencillo de
usar y nos facilita más el manejo del proyecto.

Es importante mencionar que para todos estos ejemplos, en cada una de las operaciones, al inicio mandamos llamar al método Create() y esto lo hacemos porque también al
final mandamos llamar al método Drop(), que lo que hacemos con este método es borrar las tablas de la base de datos, es por eso por lo que al inicio mandamos llamar al método
Create() para crear nuevamente las tablas, pero esto es solo por ser meros ejemplos, así que para cuando estemos usando el proyecto OKHOSTING.ORM, no es
necesario hacer la llamada a estos métodos a menos que en realidad queramos borrar o crear las tablas.[/vc_column_text][/vc_column][/vc_row][vc_row el_id=”orderby” css=”.vc_custom_1464128154711{padding-top: 110px !important;}”][vc_column][vc_column_text]

12.- OrderBy

En el proyecto OKHOSTING.ORM podemos hacer ordenaciones de los datos por medio de la sentencia OrderBy y de una manera muy sencilla solo indicándole por medio de que
columna queremos la ordenación de los datos e indicándole en que orden lo queremos ya sea ascendente o descendente, así como en el siguiente ejemplo:

CustomerContact contact = new CustomerContact();

        contact.Customer = new Customer();
        contact.Customer.LegalName = "Empresa " + i;
        contact.Customer.Phone = i.ToString();
        contact.Customer.Email= "empres@a.com" + i;
        DataBase.Insert(contact.Customer);

        contact.Firstname = "Argentina " + i;
        contact.LastName = "Chichona";
        contact.BirthDate = new DateTime(1980, 1, 1).AddDays(i);
        DataBase.Insert(contact);

        Select select = new Select();

	select.OrderBy.Add(new Operations.OrderBy() { Member = dtype[x => x.Id], Direction = Data.SortDirection.Descending });

Aquí lo que hacemos es ordenar los datos que nos arroja un select, ordenándolos por medio de la columna Id y en orden descendente.[/vc_column_text][/vc_column][/vc_row]