public void Test001()
{
string nativeSql = @"SELECT DISTINCT
employee.FirstName
FROM
employee
WHERE
employee.Title = 'IT Staff'";
var p = sqlCommand.CreateParameter();
p.ParameterName = "p10";
p.DbType = DbType.String;
p.Value = "IT Staff";
sqlCommand.Parameters.Add(p);
SqlTableRef employees = SqlDml.TableRef(schema.Tables["employee"]);
SqlSelect select = SqlDml.Select(employees);
select.Distinct = true;
select.Columns.AddRange(employees["FirstName"]);
select.Where = employees["Title"] == SqlDml.ParameterRef(p.ParameterName);
Assert.IsTrue(CompareExecuteDataReader(nativeSql, select));
}
private void JoinViaIn(SqlStatement statement, SqlSelect @select)
{
SqlTableRef table = GetStatementTable(statement);
SqlExpression where = GetStatementWhere(statement);
JoinedTableRef = table;
PrimaryIndexMapping indexMapping = PrimaryIndexes[0];
var columns = new List <ColumnInfo>();
foreach (ColumnInfo columnInfo in indexMapping.PrimaryIndex.KeyColumns.Keys)
{
SqlSelect s = select.ShallowClone();
foreach (ColumnInfo column in columns)
{
SqlBinary ex = SqlDml.Equals(SqlDml.TableColumn(s.From, column.Name), SqlDml.TableColumn(table, column.Name));
s.Where = s.Where.IsNullReference() ? ex : SqlDml.And(s.Where, ex);
}
s.Columns.Clear();
s.Columns.Add(SqlDml.TableColumn(s.From, columnInfo.Name));
SqlBinary @in = SqlDml.In(SqlDml.TableColumn(table, columnInfo.Name), s);
@where = @where.IsNullReference() ? @in : SqlDml.And(@where, @in);
columns.Add(columnInfo);
}
SetStatementWhere(statement, where);
}
public void Test008()
{
string nativeSql = @"SELECT
t.TrackId,
t.[Name],
a.[Title]
FROM
Track t
INNER JOIN Album a ON (t.AlbumId = a.AlbumId)
ORDER BY
t.TrackId";
SqlTableRef track = SqlDml.TableRef(schema.Tables["Track"], "t");
SqlTableRef album = SqlDml.TableRef(schema.Tables["Album"], "a");
SqlSelect select = SqlDml.Select(track.InnerJoin(album, track["AlbumId"] == album["AlbumId"]));
select.Columns.Add(track["TrackId"]);
select.Columns.Add(track["Name"]);
select.Columns.Add(album["Title"]);
select.OrderBy.Add(track["TrackId"]);
Assert.IsTrue(CompareExecuteDataReader(nativeSql, select));
}
public void SqlMatchReplacingTest()
{
SqlTableRef t = SqlDml.TableRef(table1);
SqlSelect s1 = SqlDml.Select(t);
s1.Columns.Add(t[0]);
s1.Columns.Add(SqlDml.Null, "ID");
SqlSelect s2 = SqlDml.Select(t);
s2.Columns.Add(t[0]);
s2.Columns.Add(t[1]);
SqlMatch m = SqlDml.Match(SqlDml.Row(1, "name"), s1, false, SqlMatchType.Partial);
SqlMatch mReplacing = SqlDml.Match(SqlDml.Row(1, "name"), s2, true, SqlMatchType.None);
m.ReplaceWith(mReplacing);
bool passed = false;
try {
m.ReplaceWith(1);
}
catch {
passed = true;
}
Assert.IsTrue(passed);
Assert.AreNotEqual(m, mReplacing);
Assert.AreEqual(m.NodeType, mReplacing.NodeType);
Assert.AreEqual(m.MatchType, mReplacing.MatchType);
Assert.AreEqual(m.Unique, mReplacing.Unique);
Assert.AreEqual(m.Value, mReplacing.Value);
Assert.AreEqual(m.SubQuery, mReplacing.SubQuery);
}
public void Test008()
{
string nativeSql = @"SELECT
t.city_id,
t.city,
c.country
FROM
city t
INNER JOIN country c ON (t.country_id = c.country_id)
ORDER BY
t.city_id";
SqlTableRef city = SqlDml.TableRef(schema.Tables["city"], "t");
SqlTableRef country = SqlDml.TableRef(schema.Tables["country"], "c");
SqlSelect select = SqlDml.Select(city.InnerJoin(country, city["country_id"] == country["country_id"]));
select.Columns.Add(city["city_id"]);
select.Columns.Add(city["city"]);
select.Columns.Add(country["country"]);
select.OrderBy.Add(city["city_id"]);
Assert.IsTrue(CompareExecuteDataReader(nativeSql, select));
}
public void SqlWhileCloneTest()
{
SqlVariable i = SqlDml.Variable("i", SqlType.Int32);
SqlWhile w = SqlDml.While(i <= 1000);
SqlBatch b = SqlDml.Batch();
b.Add(SqlDml.Assign(i, i + 1));
SqlTableRef t = SqlDml.TableRef(table1);
SqlSelect s = SqlDml.Select(t);
s.Columns.Add(t["Name"]);
s.Where = t[0] == i;
SqlIf f = SqlDml.If(SqlDml.SubQuery(s) == "Unkown", SqlDml.Break, SqlDml.Continue);
b.Add(f);
w.Statement = b;
SqlWhile wClone = (SqlWhile)w.Clone();
Assert.AreNotEqual(w, wClone);
Assert.AreEqual(w.NodeType, wClone.NodeType);
Assert.AreNotEqual(w.Condition, wClone.Condition);
Assert.AreEqual(w.Condition.NodeType, wClone.Condition.NodeType);
Assert.AreNotEqual(w.Statement, wClone.Statement);
Assert.AreEqual(w.Statement.NodeType, wClone.Statement.NodeType);
}
public void Test000()
{
string nativeSql = @"SELECT
employee.EmployeeID,
employee.FirstName,
employee.LastName,
employee.BirthDate
FROM
employee
WHERE
employee.FirstName = 'Robert'
ORDER BY
employee.LastName";
var p = sqlCommand.CreateParameter();
p.ParameterName = "p1";
p.DbType = DbType.String;
p.Value = "Robert";
sqlCommand.Parameters.Add(p);
SqlTableRef employees = SqlDml.TableRef(schema.Tables["employee"]);
SqlSelect select = SqlDml.Select(employees);
select.Columns.AddRange(employees["EmployeeId"], employees["FirstName"], employees["LastName"], employees["BirthDate"]);
select.Where = employees["FirstName"] == SqlDml.ParameterRef(p.ParameterName);
select.OrderBy.Add(employees["LastName"]);
Assert.IsTrue(CompareExecuteDataReader(nativeSql, select));
}
public void Test027()
{
string nativeSql = @"SELECT
c.customer_id,
c.first_name
FROM
customer c
WHERE EXISTS
(SELECT * FROM payment p WHERE p.amount > 11.00 AND p.customer_id = c.customer_id )";
SqlTableRef customer = SqlDml.TableRef(schema.Tables["customer"], "c");
SqlTableRef payment = SqlDml.TableRef(schema.Tables["payment"], "p");
SqlSelect innerSelect = SqlDml.Select(payment);
SqlSelect select = SqlDml.Select(customer);
innerSelect.Columns.Add(SqlDml.Asterisk);
innerSelect.Where = payment["amount"] > 11.00 && payment["customer_id"] == customer["customer_id"];
select.Columns.Add(customer["customer_id"]);
select.Columns.Add(customer["first_name"]);
select.Where = SqlDml.Exists(innerSelect);
Assert.IsTrue(CompareExecuteDataReader(nativeSql, select));
}
public void SqlUpdateCloneTest()
{
SqlTableRef t = SqlDml.TableRef(table1);
SqlUpdate u = SqlDml.Update(t);
u.Values[t[0]] = 1;
u.Values[t[1]] = "Anonym";
u.Where = t.Columns["ID"] == 1;
u.Hints.Add(SqlDml.FastFirstRowsHint(10));
SqlUpdate uClone = (SqlUpdate)u.Clone();
Assert.AreNotEqual(u, uClone);
Assert.AreNotEqual(u.Update, uClone.Update);
Assert.AreEqual(u.NodeType, uClone.NodeType);
Assert.AreEqual(u.Values.Count, uClone.Values.Count);
foreach (KeyValuePair <ISqlLValue, SqlExpression> p in u.Values)
{
Assert.IsFalse(uClone.Values.ContainsKey(p.Key));
Assert.IsFalse(uClone.Values.ContainsValue(p.Value));
}
if (u.Where != null)
{
Assert.AreNotEqual(u.Where, uClone.Where);
Assert.AreEqual(u.Where.NodeType, uClone.Where.NodeType);
}
else
{
Assert.AreEqual(uClone.Where, null);
}
Assert.AreEqual(u.Hints.Count, uClone.Hints.Count);
}
public void Test023()
{
string nativeSql = @"SELECT
f.film_id,
f.title,
f.description,
f.length
FROM
film f
WHERE
(f.rating = 'PG' OR
f.rating = 'PG-13') AND
f.length < 100
ORDER BY
f.film_id";
SqlTableRef film = SqlDml.TableRef(schema.Tables["film"], "f");
SqlSelect select = SqlDml.Select(film);
select.Columns.AddRange(film["film_id"], film["title"], film["description"], film["length"]);
select.Where = (film["rating"] == "PG" || film["rating"] == "PG-13") && film["length"] < 100;
select.OrderBy.Add(film["film_id"]);
Assert.IsTrue(CompareExecuteDataReader(nativeSql, select));
}
public void Test026()
{
string nativeSql = @"SELECT
p.customer_id,
p.amount
FROM
payment p
WHERE
p.amount = (SELECT MAX(amount) AS LowestPayment FROM payment)";
SqlTableRef payment1 = SqlDml.TableRef(schema.Tables["payment"], "p1");
SqlTableRef payment2 = SqlDml.TableRef(schema.Tables["payment"], "p2");
SqlSelect innerSelect = SqlDml.Select(payment2);
innerSelect.Columns.Add(SqlDml.Max(payment2["amount"]));
SqlSelect select = SqlDml.Select(payment1);
select.Columns.Add(payment1["customer_id"]);
select.Columns.Add(payment1["amount"]);
select.Where = SqlDml.Equals(payment1["amount"], innerSelect);
Assert.IsTrue(CompareExecuteDataReader(nativeSql, select));
}
public void Test018()
{
string nativeSql = @"SELECT
c.customer_id,
c.first_name,
c.last_name,
SUM(p.amount) AS Total
FROM
customer c
INNER JOIN payment p ON (c.customer_id = p.customer_id)
GROUP BY
c.customer_id,
c.first_name,
c.last_name
HAVING SUM(p.amount) > 140";
SqlTableRef customer = SqlDml.TableRef(schema.Tables["customer"], "c");
SqlTableRef payment = SqlDml.TableRef(schema.Tables["payment"], "p");
SqlSelect select = SqlDml.Select(customer.InnerJoin(payment, customer["customer_id"] == payment["customer_id"]));
select.Columns.Add(customer["customer_id"]);
select.Columns.Add(customer["first_name"]);
select.Columns.Add(customer["last_name"]);
select.Columns.Add(SqlDml.Sum(payment["amount"]), "Total");
select.GroupBy.Add(customer["customer_id"]);
select.GroupBy.Add(customer["first_name"]);
select.GroupBy.Add(customer["last_name"]);
select.Having = SqlDml.Sum(payment["amount"]) > 140;
Assert.IsTrue(CompareExecuteDataReader(nativeSql, select));
}
public void Test019()
{
string nativeSql = @"SELECT
c.customer_id,
c.first_name,
c.last_name
FROM
customer c
WHERE c.customer_id IN (SELECT r.customer_id FROM rental r WHERE r.inventory_id = 239)
GROUP BY c.customer_id,
c.first_name,
c.last_name";
SqlTableRef customer = SqlDml.TableRef(schema.Tables["customer"], "c");
SqlTableRef rental = SqlDml.TableRef(schema.Tables["rental"], "r");
SqlSelect innerSelect = SqlDml.Select(rental);
innerSelect.Columns.Add(rental["customer_id"]);
innerSelect.Where = rental["inventory_id"] == 239;
SqlSelect select = SqlDml.Select(customer);
select.Columns.Add(customer["customer_id"]);
select.Columns.Add(customer["first_name"]);
select.Columns.Add(customer["last_name"]);
select.Where = SqlDml.In(customer["customer_id"], innerSelect);
select.GroupBy.Add(customer["customer_id"]);
select.GroupBy.Add(customer["first_name"]);
select.GroupBy.Add(customer["last_name"]);
Assert.IsTrue(CompareExecuteDataReader(nativeSql, select));
}
public void Test014()
{
string nativeSql = @"SELECT
r.inventory_id,
r.return_date, r.rental_date,
DATEDIFF(r.return_date, r.rental_date) Days
FROM
rental r
WHERE
r.return_date IS NOT NULL
ORDER BY
r.inventory_id";
SqlTableRef rental = SqlDml.TableRef(schema.Tables["rental"], "r");
SqlSelect select = SqlDml.Select(rental);
select.Columns.AddRange(rental["inventory_id"], rental["return_date"], rental["rental_date"]);
select.Columns.Add(
SqlDml.FunctionCall("DATEDIFF", rental["return_date"], rental["rental_date"]),
"Days"
);
select.Where = SqlDml.IsNotNull(rental["return_date"]);
select.OrderBy.Add(rental["inventory_id"]);
Assert.IsTrue(CompareExecuteDataReader(nativeSql, select));
}
public void Test012()
{
string nativeSql = @"SELECT
CASE p.staff_id
WHEN 1 THEN 'STAFF_1'
WHEN 2 THEN 'STAFF_2'
ELSE 'STAFF_OTHER'
END AS Staff,
SUM(p.amount) AS Total
FROM
payment p
GROUP BY
p.staff_id";
SqlTableRef payment = SqlDml.TableRef(schema.Tables["payment"], "p");
SqlSelect select = SqlDml.Select(payment);
SqlCase totalPayment = SqlDml.Case(payment["staff_id"]);
totalPayment[1] = SqlDml.Literal("STAFF_1");
totalPayment[2] = SqlDml.Literal("STAFF_2");
totalPayment.Else = SqlDml.Literal("STAFF_OTHER");
select.Columns.Add(totalPayment, "Staff");
select.Columns.Add(SqlDml.Sum(payment["amount"]), "Total");
select.GroupBy.AddRange(payment["staff_id"]);
Assert.IsTrue(CompareExecuteDataReader(nativeSql, select));
}
public void Test011()
{
string nativeSql = @"SELECT
c.customer_id,
c.first_name,
c.last_name,
SUM(p.amount) AS Total
FROM
customer c
INNER JOIN payment p ON (c.customer_id = p.customer_id)
GROUP BY
c.customer_id,
c.first_name,
c.last_name
ORDER BY c.customer_id";
SqlTableRef customer = SqlDml.TableRef(schema.Tables["customer"], "c");
SqlSelect select = SqlDml.Select(customer);
select.Columns.AddRange(customer["customer_id"], customer["first_name"], customer["last_name"]);
SqlTableRef payment = SqlDml.TableRef(schema.Tables["payment"], "p");
SqlSelect sumOfPayment = SqlDml.Select(payment);
sumOfPayment.Columns.Add(SqlDml.Sum(payment["amount"]));
sumOfPayment.Where = customer["customer_id"] == payment["customer_id"];
select.Columns.Add(sumOfPayment, "Total");
select.OrderBy.Add(customer["customer_id"]);
Assert.IsTrue(CompareExecuteDataReader(nativeSql, select));
}
public void Test012()
{
string nativeSql = @"SELECT
CASE il.TrackId
WHEN 1 THEN 'STAFF_1'
WHEN 2 THEN 'STAFF_2'
ELSE 'STAFF_OTHER'
END AS shippers,
SUM(il.UnitPrice) AS TotalUnits
FROM [invoiceline] il
GROUP BY il.TrackId";
SqlTableRef invoiceLine = SqlDml.TableRef(schema.Tables["invoiceline"], "il");
SqlSelect select = SqlDml.Select(invoiceLine);
SqlCase totalPayment = SqlDml.Case(invoiceLine["TrackId"]);
totalPayment[1] = SqlDml.Literal("STAFF_1");
totalPayment[2] = SqlDml.Literal("STAFF_2");
totalPayment.Else = SqlDml.Literal("STAFF_OTHER");
select.Columns.Add(totalPayment, "shippers");
select.Columns.Add(SqlDml.Sum(invoiceLine["UnitPrice"]), "TotalUnits");
select.GroupBy.AddRange(invoiceLine["TrackId"]);
Assert.IsTrue(CompareExecuteDataReader(nativeSql, select));
}
public void Test001()
{
string nativeSql =
@"SELECT DISTINCT
actor.first_name
FROM
actor
WHERE
actor.first_name = 'ADAM'";
var p = sqlCommand.CreateParameter();
p.ParameterName = "p10";
p.DbType = DbType.String;
p.Value = "ADAM";
sqlCommand.Parameters.Add(p);
SqlTableRef actor = SqlDml.TableRef(schema.Tables["actor"]);
SqlSelect select = SqlDml.Select(actor);
select.Distinct = true;
select.Columns.AddRange(actor["first_name"]);
select.Where = actor["first_name"] == SqlDml.ParameterRef(p.ParameterName);
Assert.IsTrue(CompareExecuteDataReader(nativeSql, select));
}
public void Test000()
{
string nativeSql =
@"SELECT
actor.actor_id,
actor.first_name,
actor.last_name,
actor.last_update
FROM
actor
WHERE
actor.first_name = 'ADAM'
ORDER BY
actor.last_name";
var p = sqlCommand.CreateParameter();
p.ParameterName = "p1";
p.DbType = DbType.String;
p.Value = "ADAM";
sqlCommand.Parameters.Add(p);
SqlTableRef actor = SqlDml.TableRef(schema.Tables["actor"]);
SqlSelect select = SqlDml.Select(actor);
select.Columns.AddRange(actor["actor_id"], actor["first_name"], actor["last_name"], actor["last_update"]);
select.Where = actor["first_name"] == SqlDml.ParameterRef(p.ParameterName);
select.OrderBy.Add(actor["last_name"]);
Assert.IsTrue(CompareExecuteDataReader(nativeSql, select));
}
private SqlInsert CreateInsert(SqlTableRef tableRef)
{
var insert = SqlDml.Insert(tableRef);
insert.Values.Add(tableRef["id"], nextId++);
return(insert);
}
public void Test026()
{
string nativeSql = @"SELECT
p.CustomerId,
p.Commission
FROM
invoice p
WHERE
p.Commission = (SELECT MIN(Commission) AS LowestCommission FROM invoice)";
SqlTableRef invoice1 = SqlDml.TableRef(schema.Tables["invoice"], "p1");
SqlTableRef invoice2 = SqlDml.TableRef(schema.Tables["invoice"], "p2");
SqlSelect innerSelect = SqlDml.Select(invoice2);
innerSelect.Columns.Add(SqlDml.Min(invoice2["Commission"]));
SqlSelect select = SqlDml.Select(invoice1);
select.Columns.Add(invoice1["CustomerId"]);
select.Columns.Add(invoice1["Commission"]);
select.Where = SqlDml.Equals(invoice1["Commission"], innerSelect);
Assert.IsTrue(CompareExecuteDataReader(nativeSql, select));
}
public void Test027()
{
string nativeSql = @"SELECT
c.CustomerId,
c.CompanyName
FROM
customer c
WHERE EXISTS
(SELECT * FROM invoice i WHERE i.Commission < 1.00 AND i.CustomerId = c.CustomerId )";
SqlTableRef customer = SqlDml.TableRef(schema.Tables["customer"], "c");
SqlTableRef invoice = SqlDml.TableRef(schema.Tables["invoice"], "i");
SqlSelect innerSelect = SqlDml.Select(invoice);
SqlSelect select = SqlDml.Select(customer);
innerSelect.Columns.Add(SqlDml.Asterisk);
innerSelect.Where = invoice["Commission"] < 11.00 && invoice["CustomerId"] == customer["CustomerId"];
select.Columns.Add(customer["CustomerId"]);
select.Columns.Add(customer["CompanyName"]);
select.Where = SqlDml.Exists(innerSelect);
Assert.IsTrue(CompareExecuteDataReader(nativeSql, select));
}
public void Test019()
{
string nativeSql = @"SELECT
c.CustomerId,
c.CompanyName,
c.LastName
FROM
customer c
WHERE c.CustomerId IN (SELECT r.CustomerId FROM invoice r WHERE r.DesignatedEmployeeId = 8)
GROUP BY c.CustomerID,
c.CompanyName,
c.LastName";
SqlTableRef customer = SqlDml.TableRef(schema.Tables["customer"], "c");
SqlTableRef invoice = SqlDml.TableRef(schema.Tables["invoice"], "r");
SqlSelect innerSelect = SqlDml.Select(invoice);
innerSelect.Columns.Add(invoice["CustomerId"]);
innerSelect.Where = invoice["DesignatedEmployeeId"] == 8;
SqlSelect select = SqlDml.Select(customer);
select.Columns.Add(customer["CustomerId"]);
select.Columns.Add(customer["CompanyName"]);
select.Columns.Add(customer["LastName"]);
select.Where = SqlDml.In(customer["CustomerId"], innerSelect);
select.GroupBy.Add(customer["CustomerID"]);
select.GroupBy.Add(customer["CompanyName"]);
select.GroupBy.Add(customer["LastName"]);
Assert.IsTrue(CompareExecuteDataReader(nativeSql, select));
}
public void Test018()
{
string nativeSql = @"SELECT
c.CustomerId,
c.CompanyName,
c.LastName,
SUM(i.commission) AS Total
FROM
customer c
INNER JOIN invoice i ON (c.CustomerID = i.CustomerID)
GROUP BY
c.CustomerId,
c.CompanyName,
c.LastName
HAVING SUM(i.commission) > 140";
SqlTableRef customer = SqlDml.TableRef(schema.Tables["customer"], "c");
SqlTableRef invoice = SqlDml.TableRef(schema.Tables["invoice"], "i");
SqlSelect select = SqlDml.Select(customer.InnerJoin(invoice, customer["CustomerId"] == invoice["CustomerId"]));
select.Columns.AddRange(customer["CustomerID"], customer["CompanyName"], customer["LastName"]);
select.Columns.Add(SqlDml.Sum(invoice["Commission"]), "Total");
select.GroupBy.AddRange(customer["CustomerID"], customer["CompanyName"], customer["LastName"]);
select.Having = SqlDml.Sum(invoice["Commission"]) > 140;
Assert.IsTrue(CompareExecuteDataReader(nativeSql, select));
}
public virtual void Visit(SqlTableRef node)
{
VisitInternal(node.Asterisk);
foreach (SqlTableColumn column in node.Columns)
{
VisitInternal(column);
}
}
public void Test017_1()
{
SqlTableRef customer = SqlDml.TableRef(schema.Tables["customer"], "c");
SqlSelect select = SqlDml.Select(customer);
select.Columns.Add(customer["CustomerId"]);
select.Columns.Add(SqlDml.RawConcat("Mr. ", customer["LastName"]), "FullName");
Console.WriteLine(sqlDriver.Compile(select).GetCommandText());
}
public void Test014_3()
{
SqlTableRef invoice = SqlDml.TableRef(schema.Tables["invoice"], "r");
SqlSelect select = SqlDml.Select(invoice);
select.Columns.Add(SqlDml.DateTimeAddMonths(invoice["PaymentDate"], 1 + 1), "TimeToToday");
select.Where = SqlDml.IsNotNull(invoice["PaymentDate"]);
Console.WriteLine(sqlDriver.Compile(select).GetCommandText());
}
public void Test014_2()
{
SqlTableRef invoice = SqlDml.TableRef(schema.Tables["invoice"], "r");
SqlSelect select = SqlDml.Select(invoice);
select.Columns.Add(SqlDml.FunctionCall("DATE", invoice["PaymentDate"], SqlDml.Native(string.Format("'{0} MONTHS'", 1 + 1))), "TimeToToday");
select.Where = SqlDml.IsNotNull(invoice["PaymentDate"]);
Console.WriteLine(sqlDriver.Compile(select).GetCommandText());
}
public void Test002()
{
string nativeSql = "SELECT * FROM [genre] a";
SqlTableRef region = SqlDml.TableRef(Catalog.Schemas["main"].Tables["genre"]);
SqlSelect select = SqlDml.Select(region);
select.Columns.Add(SqlDml.Asterisk);
Assert.IsTrue(CompareExecuteDataReader(nativeSql, select));
}
public void Test002()
{
string nativeSql = "SELECT * FROM `city` `a`";
SqlTableRef city = SqlDml.TableRef(schema.Tables["city"]);
SqlSelect select = SqlDml.Select(city);
select.Columns.Add(SqlDml.Asterisk);
Assert.IsTrue(CompareExecuteDataReader(nativeSql, select));
}
