Define an alias for the models, to use in queries.

            var t0 = new Orders().AsQueryable();

"Sql Commands" (such as AS, AVG, DISTINCT etc.) can be used via helper parameter that comes with expression function.

			Odb.SQL.Select(x => ... x[table-field].SqlCommand ... );

CONSTANT Selects a contant value.

		Odb.SQL.Select(x =>
			x.Fields(
				{{hl}}5.60{{/hl}}, {{hl}}"str1"{{/hl}}, {{hl}}x[5.63].AS("C1"){{/hl}}
			)
		);

SELECT 5.60, 'str1', 5.63 AS C1 AS Renames a column with an alias.

		Odb.SQL.Select(x => 
			x.From(t0)
			 .Fields(
				x["X"].{{hl}}AS("C1"){{/hl}}, x[t0.OrderID].{{hl}}AS("OID"){{/hl}}
			 )
		);

SELECT 'X' AS C1, t0.OrderID AS OID
FROM [Orders] AS t0 IN / NOT IN IN command allows you to specify multiple values in a WHERE clause.

		var vals1 = new[] {1, 2};
		var vals2 = new[] {"A", "B", "C"};

		Odb.SQL.Select(x => 
			x.From(t0)
			 .Where( x[t0.OrderID].{{hl}}IN(vals1){{/hl}} & 
					 x[t0.EmployeeID].{{hl}}NOT_IN(vals2){{/hl}}
			)
		);

SELECT *
FROM [Orders] AS t0
WHERE
t0.OrderID IN (1, 2) AND
t0.EmployeeID NOT IN ('A', 'B', 'C') IS NULL / IS NOT NULL

		Odb.SQL.Select(x => 
			x.From(t0)
			 .Where( (object)t0.OrderID {{hl}}== DBNull.Value{{/hl}} & 
					 (object)t0.EmployeeID {{hl}}!= DBNull.Value{{/hl}}
			)
		);

SELECT *
FROM [Orders] AS t0
WHERE
t0.OrderID IS NULL AND
t0.EmployeeID IS NOT NULL LIKE is used in a WHERE clause to search for a specified pattern in a column.

		Odb.SQL.Select(x => 
			x.From(t0)
			 .Where( x[t0.Country].{{hl}}STARTS_WITH("A"){{/hl}} | 
					 x[t0.Country].{{hl}}ENDS_WITH("Z"){{/hl}} | 
					 x[t0.Country].{{hl}}CONTAINS("M"){{/hl}}
			 )
		);

SELECT *
FROM [Customers] AS t0
WHERE
t0.Country LIKE 'A%' OR
t0.Country LIKE '%Z' OR
t0.CountryLIKE '%M%' DISTINCT Inside a table, a column often contains many duplicate values; and sometimes you only want to list the different (distinct) values. The DISTINCT statement is used to return only distinct (different) values.

		Odb.SQL.Select(x => 
			x.From(t0)
			 .Fields(
				{{hl}}x{{/hl}}[t0.Country].{{hl}}DISTINCT(){{/hl}}.AS("C")
			)
		);

SELECT
DISTINCT(th.year) AS 'C'
FROM [Customers] AS t0
COALESCE Return the first non-null value in a list.

		Odb.SQL.Select(x => 
			x.From(t0)
			 .Fields( 
				{{hl}}x{{/hl}}[t0.CustomerName].{{hl}}COALESCE('???'){{/hl}}.AS("C")
			)
		);

SELECT
COALESCE(t0.CustomerName, '???') AS 'C'
FROM [Customers] AS t0
Aggregate Functions

		Odb.SQL.Select(x => 
			x.From(t0)
			 .{{hl}}GroupBy(t0.Country){{/hl}}
			 .Fields( th.Country, 
					  {{hl}}x{{/hl}}[t0.CustomerID].{{hl}}AVG(){{/hl}}.AS("C1"), 
					  {{hl}}x{{/hl}}[t0.CustomerID].{{hl}}MIN(){{/hl}}.AS("C2"), 
					  {{hl}}x{{/hl}}[t0.CustomerID].{{hl}}MAX(){{/hl}}.AS("C3"), 
					  {{hl}}x{{/hl}}[t0.CustomerID].{{hl}}SUM(){{/hl}}.AS("C4")
			  )
		);

SELECT t0.Country, AVG(t0.CustomerID) AS 'C1',
MIN(t0.CustomerID) AS 'C2',
MAX(t0.CustomerID) AS 'C3',
SUM(t0.CustomerID) AS 'C4' FROM [Customers] AS t0
GROUP BY t0.Country String Functions

		Odb.SQL.Select(x =>
			x.From(t0)
			 .Fields( {{hl}}x{{/hl}}[t0.City].{{hl}}SUBSTRING(2, 4){{/hl}}.AS("2_to_4"), 
					  {{hl}}x{{/hl}}[t0.City].{{hl}}SUBSTRING(0, 1){{/hl}}.AS("left_1"), 
					  {{hl}}x{{/hl}}[t0.City].{{hl}}SUBSTRING(-1, 2){{/hl}}.AS("right_2"), 
					  {{hl}}x{{/hl}}[t0.City].{{hl}}UPPER(){{/hl}}.AS("C1"), 
					  {{hl}}x{{/hl}}[t0.City].{{hl}}LOWER(){{/hl}}.AS("C2"), 
					  {{hl}}x{{/hl}}[t0.City].{{hl}}TRIM(){{/hl}}.AS("C3"), 
					  {{hl}}x{{/hl}}[t0.City].{{hl}}RTRIM().LTRIM(){{/hl}}.AS("C4"), 
					  {{hl}}x{{/hl}}[t0.City].{{hl}}CONCAT(", ID=", t0.CustomerID){{/hl}}.AS("C5")
			  )
		);

SELECT SUBSTRING(t0.City) AS '2_to_4',
LEFT(t0.City, 1) AS 'left_1',
RIGHT(t0.City, 2) AS 'right_2',
UPPER(t0.City) AS 'C1',
LOWER(t0.City) AS 'C2',
TRIM(t0.City) AS 'C3',
LTRIM(RTRIM(t0.City)) AS 'C4',
CONCAT(t0.City, ', ID=', t0.CustomerID) AS 'C5' FROM [Customer] AS t0