protected override ICSDbCommand CreateCommand(string sqlQuery, CSParameterCollection parameters)
{
SqlCommand sqlCommand = ((CSSqlCommand) Connection.CreateCommand()).Command;
if (CurrentTransaction != null)
sqlCommand.Transaction = ((CSSqlTransaction) CurrentTransaction).Transaction;
if (sqlQuery.StartsWith("!"))
{
sqlCommand.CommandType = CommandType.StoredProcedure;
sqlCommand.CommandText = sqlQuery.Substring(1);
}
else
{
sqlCommand.CommandType = CommandType.Text;
sqlCommand.CommandText = sqlQuery;
}
if (parameters != null && !parameters.IsEmpty)
foreach (CSParameter csParameter in parameters)
{
IDbDataParameter dataParameter = sqlCommand.CreateParameter();
dataParameter.ParameterName = csParameter.Name;
dataParameter.Direction = ParameterDirection.Input;
dataParameter.Value = ConvertParameter(csParameter.Value);
sqlCommand.Parameters.Add(dataParameter);
}
return new CSSqlCommand(sqlCommand);
}
protected override IDbCommand CreateCommand(string sqlQuery, CSParameterCollection parameters)
{
DB2Command dbCommand = (DB2Command)Connection.CreateCommand();
dbCommand.Transaction = (DB2Transaction)CurrentTransaction;
if (parameters != null && !parameters.IsEmpty)
{
int paramNum = 1;
foreach (Match m in Regex.Matches(sqlQuery, "@[a-z_0-9]+", RegexOptions.IgnoreCase))
{
if (parameters[m.Value] == null)
throw new CSException("Parameter " + m.Value + " undefined");
dbCommand.Parameters.Add(new DB2Parameter("@P" + (paramNum++), ConvertParameter(parameters[m.Value].Value)));
}
sqlQuery = Regex.Replace(sqlQuery, "@[a-z_0-9]+", "?", RegexOptions.IgnoreCase);
}
if (sqlQuery.StartsWith("!"))
{
dbCommand.CommandType = CommandType.StoredProcedure;
dbCommand.CommandText = sqlQuery.Substring(1);
}
else
{
dbCommand.CommandType = CommandType.Text;
dbCommand.CommandText = sqlQuery;
}
return dbCommand;
}
protected override ICSDbCommand CreateCommand(string sqlQuery, CSParameterCollection parameters)
{
SqliteCommand sqlCommand = ((CSSqliteCommand)Connection.CreateCommand()).Command;
if (CurrentTransaction != null)
sqlCommand.Transaction = ((CSSqliteTransaction)CurrentTransaction).Transaction;
if (sqlQuery.ToUpper().StartsWith("DELETE ") || sqlQuery.ToUpper().StartsWith("SELECT ") || sqlQuery.ToUpper().StartsWith("UPDATE ") || sqlQuery.ToUpper().StartsWith("INSERT ") || sqlQuery.ToUpper().StartsWith("CREATE "))
sqlCommand.CommandType = CommandType.Text;
else
sqlCommand.CommandType = CommandType.StoredProcedure;
sqlCommand.CommandText = Regex.Replace(sqlQuery, @"@(?<name>[a-z0-9A-Z_]+)", "@${name}");
if (parameters != null && !parameters.IsEmpty)
foreach (CSParameter parameter in parameters)
{
IDbDataParameter dataParameter = sqlCommand.CreateParameter();
dataParameter.ParameterName = "@" + parameter.Name.Substring(1);
dataParameter.Direction = ParameterDirection.Input;
dataParameter.Value = ConvertParameter(parameter.Value);
sqlCommand.Parameters.Add(dataParameter);
}
return new CSSqliteCommand(sqlCommand);
}
/// <summary>
/// Recupera los nombres y tipos de los parametros de un stored procedure
/// </summary>
/// <param name="StoredProcedureName">Nombre del stored procedure</param>
/// <param name="WithReturn">Si debe incluir en los parametros el tipo de retorno o no</param>
/// <returns>Un array de SqlParameter con los parametros que espera (y devuelve, si aplica) el stored procedure</returns>
public static CSParameterCollection GetSpParams(this CSDataProvider dp, string StoredProcedureName, bool WithReturn)
{
//Cache
CSParameterCollection pc;
CSParameterCollection pcRet;
if (_map.ContainsKey(StoredProcedureName))
{
pc = _map[StoredProcedureName];
}
else
{
pc = InternalGetSpParams(dp, StoredProcedureName, WithReturn);
_map[StoredProcedureName] = pc;
}
pcRet = new CSParameterCollection(pc);
pcRet.ForEach<CSParameter>(param =>
{
if (param.Direction.BitOn(ParameterDirection.Output))
{
param.Value = DBNull.Value;
if (!param.Size.HasValue || param.Size == 0)
{
param.Size = 1024;
}
}
});
return pcRet;
}
protected override ICSDbCommand CreateCommand(string sqlQuery, CSParameterCollection parameters)
{
MySqlCommand mySqlCommand = ((CSSqlCommand)Connection.CreateCommand()).Command;
if (CurrentTransaction != null)
mySqlCommand.Transaction = ((CSSqlTransaction)CurrentTransaction).Transaction;
if (sqlQuery.StartsWith("!"))
{
mySqlCommand.CommandType = CommandType.StoredProcedure;
mySqlCommand.CommandText = sqlQuery.Substring(1);
}
else
{
mySqlCommand.CommandType = CommandType.Text;
mySqlCommand.CommandText = sqlQuery;
}
mySqlCommand.CommandText = Regex.Replace(sqlQuery, @"@(?<name>[a-z0-9A-Z_]+)", "?${name}");
if (parameters != null && !parameters.IsEmpty)
foreach (CSParameter parameter in parameters)
{
IDbDataParameter dataParameter = mySqlCommand.CreateParameter();
dataParameter.ParameterName = "?" + parameter.Name.Substring(1);
dataParameter.Direction = ParameterDirection.Input;
dataParameter.Value = ConvertParameter(parameter.Value);
mySqlCommand.Parameters.Add(dataParameter);
}
return new CSSqlCommand(mySqlCommand);
}
protected override ICSDbCommand CreateCommand(string sqlQuery, CSParameterCollection parameters)
{
// The next line works around a bug in the C#-Sqlite implementation
// https://code.google.com/p/csharp-sqlite/issues/detail?id=152
sqlQuery = sqlQuery.Replace("count(*)", "sum(1)");
SqliteCommand sqlCommand = ((CSSqliteCommand)Connection.CreateCommand()).Command;
if (CurrentTransaction != null)
sqlCommand.Transaction = ((CSSqliteTransaction)CurrentTransaction).Transaction;
if (sqlQuery.ToUpper().StartsWith("DELETE ") || sqlQuery.ToUpper().StartsWith("SELECT ") || sqlQuery.ToUpper().StartsWith("UPDATE ") || sqlQuery.ToUpper().StartsWith("INSERT ") || sqlQuery.ToUpper().StartsWith("CREATE "))
sqlCommand.CommandType = CommandType.Text;
else
sqlCommand.CommandType = CommandType.StoredProcedure;
sqlCommand.CommandText = Regex.Replace(sqlQuery, @"@(?<name>[a-z0-9A-Z_]+)", "@${name}");
if (parameters != null && !parameters.IsEmpty)
foreach (CSParameter parameter in parameters)
{
var sqliteParameter = (SqliteParameter) sqlCommand.CreateParameter();
sqliteParameter.ParameterName = "@" + parameter.Name.Substring(1);
sqliteParameter.Direction = ParameterDirection.Input;
sqliteParameter.Value = ConvertParameter(parameter.Value);
sqlCommand.Parameters.Add(sqliteParameter);
}
return new CSSqliteCommand(sqlCommand);
}
protected override ICSDbCommand CreateCommand(string sqlQuery, CSParameterCollection parameters)
{
SqliteCommand sqlCommand = ((CSSqliteCommand)Connection.CreateCommand()).Command;
if (CurrentTransaction != null)
{
sqlCommand.Transaction = ((CSSqliteTransaction)CurrentTransaction).Transaction;
}
sqlCommand.CommandType = CommandType.Text;
sqlCommand.CommandText = Regex.Replace(sqlQuery, @"@(?<name>[a-z0-9A-Z_]+)", "@${name}");
if (parameters != null && !parameters.IsEmpty)
{
foreach (CSParameter parameter in parameters)
{
IDbDataParameter dataParameter = sqlCommand.CreateParameter();
dataParameter.ParameterName = "@" + parameter.Name.Substring(1);
dataParameter.Direction = ParameterDirection.Input;
dataParameter.Value = ConvertParameter(parameter.Value);
sqlCommand.Parameters.Add(dataParameter);
}
}
return(new CSSqliteCommand(sqlCommand));
}
protected override ICSDbCommand CreateCommand(string sqlQuery, CSParameterCollection parameters)
{
SqliteCommand sqlCommand = ((CSSqliteCommand)Connection.CreateCommand()).Command;
if (CurrentTransaction != null)
sqlCommand.Transaction = ((CSSqliteTransaction)CurrentTransaction).Transaction;
sqlCommand.CommandType = CommandType.Text;
sqlCommand.CommandText = Regex.Replace(sqlQuery, @"@(?<name>[a-z0-9A-Z_]+)", "@${name}");
if (parameters != null && !parameters.IsEmpty)
foreach (CSParameter parameter in parameters)
{
SqliteParameter dataParameter = sqlCommand.CreateParameter();
dataParameter.ParameterName = "@" + parameter.Name.Substring(1);
dataParameter.Direction = ParameterDirection.Input;
dataParameter.Value = ConvertParameter(parameter.Value);
sqlCommand.Parameters.Add(dataParameter);
}
return new CSSqliteCommand(sqlCommand);
}
protected override ICSDbCommand CreateCommand (string sqlQuery, CSParameterCollection parameters)
{
OleDbCommand dbCommand = ((CSAccessCommand)Connection.CreateCommand ()).Command;
dbCommand.Transaction = ((CSAccessTransaction)CurrentTransaction).Transaction;
foreach (Match m in Regex.Matches(sqlQuery, "(?<!@)@[a-z_0-9]+", RegexOptions.IgnoreCase)) {
dbCommand.Parameters.AddWithValue (m.Value, ConvertParameter (parameters [m.Value].Value));
}
sqlQuery = Regex.Replace (sqlQuery, "(?<!@)@[a-z_0-9]+", "?", RegexOptions.IgnoreCase);
dbCommand.CommandType = CommandType.Text;
dbCommand.CommandText = sqlQuery;
return new CSAccessCommand (dbCommand);
}
/// <summary>
/// Recupera los nombres y tipos de los parametros de un stored procedure
/// </summary>
/// <param name="StoredProcedureName">Nombre del stored procedure</param>
/// <param name="WithReturn">Si debe incluir en los parametros el tipo de retorno o no</param>
/// <returns>Un array de SqlParameter con los parametros que espera (y devuelve, si aplica) el stored procedure</returns>
private static CSParameterCollection InternalGetSpParams(CSDataProvider dp, string StoredProcedureName, bool WithReturn)
{
CSParameterCollection _SPParameters;
using (ICSDbCommand dbCommand = dp.CreateCommandInternal(String.Format("!{0}", StoredProcedureName), null))
{
//Asigna el tipo a stored procedure, porque solo se pueden recuperar los parametros de sp's
try
{
//SqlCommandBuilder.DeriveParameters(cmd);
dp.DeriveParameters(dbCommand);
}
catch (InvalidOperationException)
{
//throw new GYF_InvalidStoredProcedureException(StoredProcedureName);
throw new Exception(StoredProcedureName);
}
//Si no debe obtener el param de retorno, lo quita
if (!WithReturn)
{
for (int i = 0; i < dbCommand.Parameters.Count; i++)
{
if (((IDbDataParameter)dbCommand.Parameters[i]).Direction == ParameterDirection.ReturnValue)
{
dbCommand.Parameters.RemoveAt(i);
break;
}
}
}
_SPParameters = new CSParameterCollection();
for (int i = 0; i < dbCommand.Parameters.Count; i++)
{
IDbDataParameter dbparam = (IDbDataParameter)dbCommand.Parameters[i];
CSParameter parameter = _SPParameters.Add(dbparam.ParameterName);
parameter.Direction = dbparam.Direction;
//if (dbparam.Size > 0)
parameter.Size = dbparam.Size;
parameter.Precision = dbparam.Precision;
parameter.Scale = dbparam.Scale;
}
}
return _SPParameters;
}
protected override ICSDbCommand CreateCommand(string sqlQuery, CSParameterCollection parameters)
{
OracleCommand oracleCommand = ((CSOracleCommand)Connection.CreateCommand()).Command;
if (CurrentTransaction != null)
oracleCommand.Transaction = ((CSOracleTransaction)CurrentTransaction).Transaction;
oracleCommand.BindByName = true;
if (sqlQuery.StartsWith("!"))
{
oracleCommand.CommandType = CommandType.StoredProcedure;
oracleCommand.CommandText = sqlQuery.Substring(1);
}
else
{
oracleCommand.CommandType = CommandType.Text;
oracleCommand.CommandText = sqlQuery;
}
oracleCommand.CommandText = Regex.Replace(sqlQuery, @"@(?<name>[a-z0-9A-Z_]+)", ":${name}");
if (parameters != null && !parameters.IsEmpty)
foreach (CSParameter parameter in parameters)
{
OracleParameter dataParameter = oracleCommand.CreateParameter();
dataParameter.ParameterName = ":" + parameter.Name.Substring(1);
dataParameter.Direction = ParameterDirection.Input;
if (parameter.Value is Guid)
dataParameter.Value = ((Guid)parameter.Value).ToByteArray();
else if (parameter.Value is Boolean)
dataParameter.Value = ((Boolean) parameter.Value) ? 1 : 0;
else
dataParameter.Value = ConvertParameter(parameter.Value);
oracleCommand.Parameters.Add(dataParameter);
}
return new CSOracleCommand(oracleCommand);
}
protected override ICSDbCommand CreateCommand(string sqlQuery, CSParameterCollection parameters)
{
// The next line works around a bug in the C#-Sqlite implementation
// https://code.google.com/p/csharp-sqlite/issues/detail?id=152
sqlQuery = sqlQuery.Replace("count(*)", "sum(1)");
SqliteCommand sqlCommand = ((CSSqliteCommand)Connection.CreateCommand()).Command;
if (CurrentTransaction != null)
{
sqlCommand.Transaction = ((CSSqliteTransaction)CurrentTransaction).Transaction;
}
if (sqlQuery.ToUpper().StartsWith("DELETE ") || sqlQuery.ToUpper().StartsWith("SELECT ") || sqlQuery.ToUpper().StartsWith("UPDATE ") || sqlQuery.ToUpper().StartsWith("INSERT ") || sqlQuery.ToUpper().StartsWith("CREATE "))
{
sqlCommand.CommandType = CommandType.Text;
}
else
{
sqlCommand.CommandType = CommandType.StoredProcedure;
}
sqlCommand.CommandText = Regex.Replace(sqlQuery, @"@(?<name>[a-z0-9A-Z_]+)", "@${name}");
if (parameters != null && !parameters.IsEmpty)
{
foreach (CSParameter parameter in parameters)
{
var sqliteParameter = (SqliteParameter)sqlCommand.CreateParameter();
sqliteParameter.ParameterName = "@" + parameter.Name.Substring(1);
sqliteParameter.Direction = ParameterDirection.Input;
sqliteParameter.Value = ConvertParameter(parameter.Value);
sqlCommand.Parameters.Add(sqliteParameter);
}
}
return(new CSSqliteCommand(sqlCommand));
}
protected override ICSDbCommand CreateCommand (string sqlQuery, CSParameterCollection parameters)
{
SqlCommand sqlCommand = ((CSSqlCommand)Connection.CreateCommand ()).Command;
if (CurrentTransaction != null)
sqlCommand.Transaction = ((CSSqlTransaction)CurrentTransaction).Transaction;
if (sqlQuery.StartsWith ("!")) {
sqlCommand.CommandType = CommandType.StoredProcedure;
sqlCommand.CommandText = sqlQuery.Substring (1);
} else {
sqlCommand.CommandType = CommandType.Text;
sqlCommand.CommandText = sqlQuery;
}
if (parameters != null && !parameters.IsEmpty)
foreach (CSParameter csParameter in parameters) {
IDbDataParameter dataParameter = sqlCommand.CreateParameter ();
dataParameter.ParameterName = csParameter.Name;
//2011-05-09 - DAE - Se agrego el soporte para parametros de salida
//dataParameter.Direction = ParameterDirection.Input;
dataParameter.Direction = csParameter.Direction;
if (csParameter.Direction.BitOn (ParameterDirection.Input))
dataParameter.Value = ConvertParameter (csParameter.Value);
if (csParameter.Size.HasValue)
dataParameter.Size = csParameter.Size.Value;
if (csParameter.Precision.HasValue)
dataParameter.Precision = csParameter.Precision.Value;
if (csParameter.Scale.HasValue)
dataParameter.Scale = csParameter.Scale.Value;
sqlCommand.Parameters.Add (dataParameter);
}
return new CSSqlCommand (sqlCommand);
}
protected override ICSDbCommand CreateCommand(string sqlQuery, CSParameterCollection parameters)
{
SqliteCommand sqlCommand = ((CSSqliteCommand)Connection.CreateCommand()).Command;
if (CurrentTransaction != null)
{
sqlCommand.Transaction = ((CSSqliteTransaction)CurrentTransaction).Transaction;
}
if (sqlQuery.ToUpper().StartsWith("DELETE ") || sqlQuery.ToUpper().StartsWith("SELECT ") || sqlQuery.ToUpper().StartsWith("UPDATE ") || sqlQuery.ToUpper().StartsWith("INSERT ") || sqlQuery.ToUpper().StartsWith("CREATE "))
{
sqlCommand.CommandType = CommandType.Text;
}
else
{
sqlCommand.CommandType = CommandType.StoredProcedure;
}
sqlCommand.CommandText = Regex.Replace(sqlQuery, @"@(?<name>[a-z0-9A-Z_]+)", "@${name}");
if (parameters != null && !parameters.IsEmpty)
{
foreach (CSParameter parameter in parameters)
{
SqliteParameter dataParameter = sqlCommand.CreateParameter();
dataParameter.ParameterName = "@" + parameter.Name.Substring(1);
dataParameter.Direction = ParameterDirection.Input;
dataParameter.Value = ConvertParameter(parameter.Value);
sqlCommand.Parameters.Add(dataParameter);
}
}
return(new CSSqliteCommand(sqlCommand));
}
protected static long Log(string cmd, CSParameterCollection parameters)
{
_numQueries++;
_lastQuery = cmd;
long logId;
lock (_logLock)
{
logId = ++_lastLogId;
if (!CSConfig.Logging)
return logId;
_logTimings.Add(logId, DateTime.Now);
try
{
using (StreamWriter writer = File.AppendText(CSConfig.LogFileName))
{
writer.WriteLine("{0} | {2:000000} | {1}", DateTime.Now.ToString("dd.MM.yyyy HH:mm:ss.fff"), cmd, logId);
if (parameters != null && parameters.Count > 0)
{
StringBuilder p = new StringBuilder();
foreach (CSParameter csParameter in parameters)
{
string value = "<null>";
if (csParameter.Value != null)
value = csParameter.Value + "(" + csParameter.Value.GetType().Name + ")";
if (value.Length > 30)
value = value.Substring(0, 30) + "...";
p.Append(csParameter.Name + "=" + ((csParameter.Value is string) ? "\"" : "") + value + ((csParameter.Value is string) ? "\"" : "") + " | ");
}
writer.WriteLine("{0} | {2:000000} | {1}", new string(' ', 23), p, logId);
}
}
}
// ReSharper disable EmptyGeneralCatchClause
catch
{
// Couldn't care less
}
// ReSharper restore EmptyGeneralCatchClause
}
return logId;
}
internal object GetScalar(string sqlQuery, CSParameterCollection parameters)
{
long logId = Log(sqlQuery, parameters);
try
{
using (ICSDbCommand dbCommand = CreateCommandInternal(sqlQuery, parameters))
{
using (ICSDbReader reader = dbCommand.ExecuteReader())
{
if (reader.Read())
{
object r = reader[0];
return (r is DBNull) ? null : r;
}
}
}
return null;
}
finally
{
LogEnd(logId);
CSNameGenerator.Reset();
}
}
protected internal int ExecuteNonQuery(string sqlQuery, CSParameterCollection parameters)
{
long logId = Log(sqlQuery, parameters);
try
{
using (ICSDbCommand dbCommand = CreateCommandInternal(sqlQuery, parameters))
dbCommand.ExecuteNonQuery();
return 1;
}
catch (InvalidOperationException)
{
return -1;
}
finally
{
LogEnd(logId);
CSNameGenerator.Reset();
}
}
protected internal virtual ICSDbReader ExecuteInsert(string tableName, string[] columnList, string[] valueList, string[] primaryKeys, string[] sequences, string identityField, CSParameterCollection parameters)
{
string sqlQuery = BuildInsertSQL(tableName, columnList, valueList, primaryKeys, sequences, identityField);
if (RequiresSeperateIdentityGet)
{
ExecuteNonQuery(sqlQuery, parameters);
sqlQuery = BuildGetKeys(tableName, columnList, valueList, primaryKeys, identityField);
}
if (sqlQuery.Length > 0)
{
if (primaryKeys != null && primaryKeys.Length > 0 && identityField != null)
return CreateReader(sqlQuery, parameters);
else
ExecuteNonQuery(sqlQuery, parameters);
}
return null;
}
protected internal ICSDbReader CreateReader(string sqlQuery, CSParameterCollection parameters)
{
long logId = Log(sqlQuery, parameters);
try
{
using (ICSDbCommand dbCommand = CreateCommandInternal(sqlQuery, parameters))
return dbCommand.ExecuteReader();
}
catch (Exception ex)
{
throw new CSException("Error executing query. Possible syntax error", ex);
}
finally
{
LogEnd(logId);
CSNameGenerator.Reset();
}
}
public CSFilter(string expression)
{
_expression = expression;
_parameters = new CSParameterCollection();
}
/// <summary>
/// TODO Completar documentación
/// </summary>
/// <param name="expression"></param>
/// <param name="parameters"></param>
public CSFilter(string expression, params CSParameter[] parameters)
{
_expression = expression;
_parameters = new CSParameterCollection(parameters);
}
/// <summary>
/// Initializes a new instance of the <see cref="CSFilter"/> class.
/// </summary>
/// <param name="expression">The expression.</param>
/// <param name="parameters">The parameters.</param>
public CSFilter(string expression, IEnumerable<CSParameter> parameters)
{
_expression = expression;
_parameters = new CSParameterCollection(parameters.ToArray());
}
/// <summary>
/// Ands this CSFilter with a new CSFilter created from the filter expression and parms.
/// </summary>
/// <param name="expression">The expression.</param>
/// <param name="parameters">The parameter collection.</param>
/// <returns>A new CSFilter</returns>
public CSFilter And(string expression, CSParameterCollection parameters)
{
return new CSFilter(this, "AND", new CSFilter(expression, parameters));
}
public CSFilter()
{
_expression = "";
_parameters = new CSParameterCollection();
}
protected CSFilter BuildRelationFilter(string tableAlias)
{
if (tableAlias == null)
{
tableAlias = "";
}
else
tableAlias += ".";
if (Relation != null)
{
CSParameterCollection parameters = new CSParameterCollection();
switch (Relation.RelationType)
{
case CSSchemaRelationType.OneToMany:
{
//DAE 2010-10-08 Soporte para claves compuestas
//CSParameter csParameter = parameters.Add();
//csParameter.Value = RelationObject.Data[String.Format("#{0}", Relation.LocalKey)].Value;
//return new CSFilter(String.Format("{{{0}{1}}}={2}", tableAlias, Relation.ForeignKey, csParameter.Name), parameters);
//CSFilter filter = new CSFilter();
string sFilter = "";
for (int i = 0; i < Relation.LocalKeys.Count; i++)
{
CSParameter csParameter = parameters.Add();
csParameter.Value = RelationObject.Data[String.Format("#{0}", Relation.LocalKeys[i])].Value;
//filter.And(String.Format("{{{0}{1}}}={2}", tableAlias, Relation.ForeignKeys[i], csParameter.Name));
sFilter += String.Format("{{{0}{1}}}={2}", tableAlias, Relation.ForeignKeys[i], csParameter.Name);
if (i < Relation.LocalKeys.Count - 1)
{
sFilter += " AND ";
}
}
//filter.Parameters.Add(parameters);
CSFilter filter = new CSFilter(sFilter, parameters);
return filter;
}
case CSSchemaRelationType.ManyToMany:
{
if (Relation.ForeignKey == null)
Relation.ForeignKey = Schema.KeyColumns[0].Name;
if (Relation.ForeignLinkKey == null)
Relation.ForeignLinkKey = Relation.ForeignKey;
CSParameter csParameter = parameters.Add();
csParameter.Value = RelationObject.Data["#" + Relation.LocalKey].Value;
return new CSFilter("{" + tableAlias + Relation.ForeignKey + "} $in ($select {" + Relation.ForeignLinkKey + "} $from [" + Relation.LinkTable + "] where {" + Relation.LocalLinkKey + "}=" + csParameter.Name + ")", parameters);
}
}
}
return CSFilter.None;
}
public void AddFilterOr(string filterExpression, CSParameterCollection parameters)
{
AddFilterOr(new CSFilter(filterExpression, parameters));
}
/// <summary>
/// Initializes a new instance of the <see cref="CSFilter"/> class.
/// </summary>
/// <param name="expression">The expression.</param>
/// <param name="paramName">Name of the param.</param>
/// <param name="paramValue">The param value.</param>
public CSFilter(string expression, string paramName, object paramValue)
{
_expression = expression;
_parameters = new CSParameterCollection(paramName, paramValue);
}
internal object GetScalar(string sqlQuery, CSParameterCollection parameters)
{
long logId = Log(sqlQuery, parameters);
try
{
using (ICSDbCommand dbCommand = CreateCommandInternal(sqlQuery, parameters))
{
using (ICSDbReader reader = dbCommand.ExecuteReader())
{
if (reader.Read())
{
object r = reader[0];
return (r == NullFieldValue()) ? null : r;
}
}
}
return null;
}
catch (Exception ex)
{
throw new CSSQLException("GetScalar exception", ex, sqlQuery, parameters);
}
finally
{
LogEnd(logId);
CSNameGenerator.Reset();
}
}
protected abstract ICSDbCommand CreateCommand(string sqlQuery, CSParameterCollection parameters);
protected override IDataReader ExecuteInsert(string tableName, string[] columnList, string[] valueList, string[] primaryKeys, string[] sequences, string identityField, CSParameterCollection parameters)
{
string sql = "";
if (columnList.Length > 0)
{
List<string> list = new List<string>();
for (int i = 0; i < valueList.Length; i++)
{
if (sequences != null && sequences[i] != null)
list.Add(QuoteField(sequences[i]) + ".nextval");
else
list.Add(valueList[i]);
}
sql += String.Format("insert into {0} ({1}) values ({2})",
QuoteTable(tableName),
String.Join(",", QuoteFieldList(columnList)),
String.Join(",", list.ToArray())
);
}
else
{
sql += String.Format("insert into {0} () values ()", QuoteTable(tableName));
}
sql += " RETURNING rowid INTO :IDVAL";
long logId = Log(sql, parameters);
OracleString rowid;
try
{
using (IDbCommand cmd = CreateCommand(sql, parameters))
{
OracleParameter parameter = new OracleParameter(":IDVAL", OracleDbType.Varchar2, 18, "ROWID");
parameter.Direction = ParameterDirection.ReturnValue;
cmd.Parameters.Add(parameter);
cmd.ExecuteNonQuery();
rowid = (OracleString) parameter.Value;
}
}
finally
{
LogEnd(logId);
}
if (primaryKeys == null || primaryKeys.Length == 0)
return null;
sql = String.Format("SELECT {0} from {1} where rowid = :IDVAL", String.Join(",", QuoteFieldList(primaryKeys)), QuoteTable(tableName));
using (IDbCommand cmd = CreateCommand(sql,null))
{
cmd.Parameters.Add(new OracleParameter(":IDVAL", rowid));
return cmd.ExecuteReader();
}
}
protected internal ICSDbCommand CreateCommandInternal(string sqlQuery, CSParameterCollection parameters)
{
ICSDbCommand command = CreateCommand(sqlQuery, parameters);
if (CSConfig.CommandTimeout.HasValue)
command.CommandTimeout = CSConfig.CommandTimeout.Value;
return command;
}
public PrefetchFilter(string foreignKey, string inStatement, CSParameterCollection parameters)
{
ForeignKey = foreignKey;
InStatement = inStatement;
Parameters = parameters;
}
public CSFilter(CSFilter sourceFilter)
{
_expression = sourceFilter._expression;
_parameters = new CSParameterCollection(sourceFilter._parameters);
}
