/// <summary>
/// Executes a prepared statement
/// </summary>
/// <param name="input_parameters">An array of values with as many elements as there are bound parameters in the SQL statement being executed. All values are treated as PDO::PARAM_STR.</param>
/// <returns>Returns TRUE on success or FALSE on failure</returns>
public virtual bool execute(PhpArray input_parameters = null)
{
if (Result != null)
{
// reusing command
Connection.ClosePendingReader();
}
// parameters
BindParameters(_cmd.Parameters, input_parameters);
// execute
Result = Connection.ExecuteCommand(_cmd, convertTypes: true, parameters: null /*already set*/, skipResults: false);
// handle error:
if (Connection.LastException == null)
{
// TODO: write-back output parameters from _cmd:
}
else
{
PDO.HandleError(Connection.LastException);
return(false);
}
return(Result != null);
}
/// <summary>
/// Initializes a new instance of the <see cref="PDOStatement" /> class.
/// </summary>
/// <param name="ctx">The php context.</param>
/// <param name="pdo">The PDO statement is created for.</param>
/// <param name="statement">The statement.</param>
/// <param name="driver_options">The driver options.</param>
internal PDOStatement(Context ctx, PDO pdo, string statement, PhpArray driver_options)
{
if (pdo.HasExecutedQuery)
{
if (!pdo.StoreLastExecutedQuery())
{
pdo.HandleError(new PDOException("Last executed PDOStatement result set could not be saved correctly."));
}
}
this.m_pdo = pdo;
this._ctx = ctx;
this.m_stmt = statement;
this.m_options = driver_options ?? PhpArray.Empty;
this.m_cmd = pdo.CreateCommand(this.m_stmt);
PrepareStatement();
this.SetDefaultAttributes();
}
private void RaiseError(string message)
{
m_pdo.HandleError(new PDOException(message));
}
private protected void HandleError(ErrorInfo error)
{
_lastError = error;
PDO.HandleError(error);
}
/// <summary>
/// Fetches the specified fetch style.
/// </summary>
/// <param name="fetch_style">Controls how the next row will be returned to the caller. This value must be one of the PDO::FETCH_* constants.</param>
/// <param name="cursor_orientation">This value determines which row will be returned to the caller.</param>
/// <param name="cursor_offet">Relative or absolute position move for the cursor.</param>
/// <returns>The return value of this function on success depends on the fetch type. In all cases, FALSE is returned on failure.</returns>
public virtual PhpValue fetch(PDO.PDO_FETCH fetch_style = PDO_FETCH.Default /*0*/, PDO_FETCH_ORI cursor_orientation = PDO_FETCH_ORI.FETCH_ORI_NEXT /*0*/, int cursor_offet = 0)
{
PDO.ClearError();
if (cursor_orientation != PDO_FETCH_ORI.FETCH_ORI_NEXT) // 0
{
throw new NotImplementedException(cursor_orientation.ToString());
}
if (Result == null)
{
throw new InvalidOperationException();
}
try
{
var how = fetch_style != PDO_FETCH.Default ? fetch_style : _default_fetch_type;
var flags = how & PDO_FETCH.Flags;
switch (how & ~PDO_FETCH.Flags)
{
case PDO_FETCH.Default:
case PDO_FETCH.FETCH_BOTH:
return(Result.FetchArray(true, true) ?? PhpValue.False);
case PDO_FETCH.FETCH_ASSOC:
return(Result.FetchAssocArray() ?? PhpValue.False);
case PDO_FETCH.FETCH_NUM:
return(Result.FetchArray(true, false) ?? PhpValue.False);
case PDO_FETCH.FETCH_OBJ:
return(ObjectOrFalse(Result.FetchStdClass()));
case PDO_FETCH.FETCH_BOUND:
return(FetchBound());
case PDO_FETCH.FETCH_COLUMN:
return(fetchColumn(_fetch_column));
case PDO.PDO_FETCH.FETCH_CLASS:
return(ObjectOrFalse(FetchClass(_default_fetch_class, _default_fetch_class_args)));
case PDO_FETCH.FETCH_NAMED:
return(this.ReadNamed());
//case PDO_FETCH.FETCH_LAZY:
// return new PDORow( ... ) reads columns lazily
//case PDO_FETCH.FETCH_INTO:
//case PDO_FETCH.FETCH_FUNC:
//case PDO_FETCH.FETCH_KEY_PAIR:
default:
throw new NotImplementedException($"fetch {how}");
}
}
catch (System.Exception ex)
{
PDO.HandleError(ex);
return(PhpValue.False);
}
}
/// <summary>
/// Prepare the PDOStatement command.
/// Set either positional, named or neither parameters mode.
/// Create the parameters, add them to the command and prepare the command.
/// </summary>
/// <returns></returns>
private bool PrepareStatement()
{
Debug.Assert(m_stmt != null && m_stmt.Length > 0);
m_namedPlaceholders = new Dictionary <string, string>();
m_positionalPlaceholders = new List <string>();
m_namedAttr = false;
m_positionalAttr = false;
int pos = 0;
var rewrittenQuery = new StringBuilder();
// Go throught the text query and find either positional or named parameters
while (pos < m_stmt.Length)
{
char currentChar = m_stmt[pos];
string paramName = "";
switch (currentChar)
{
case '?':
if (m_namedAttr)
{
throw new PDOException("Mixing positional and named parameters not allowed. Use only '?' or ':name' pattern");
}
m_positionalAttr = true;
paramName = "@p" + m_positionalPlaceholders.Count();
m_positionalPlaceholders.Add(paramName);
rewrittenQuery.Append(paramName);
break;
case ':':
if (m_positionalAttr)
{
throw new PDOException("Mixing positional and named parameters not allowed.Use only '?' or ':name' pattern");
}
m_namedAttr = true;
var match = regName.Match(m_stmt, pos);
string param = match.Value;
paramName = "@" + param;
m_namedPlaceholders[param] = paramName;
rewrittenQuery.Append(paramName);
pos += param.Length;
break;
case '"':
rewrittenQuery.Append(currentChar);
pos = SkipQuotedWord(m_stmt, rewrittenQuery, pos, '"');
break;
case '\'':
rewrittenQuery.Append(currentChar);
pos = SkipQuotedWord(m_stmt, rewrittenQuery, pos, '\'');
break;
default:
rewrittenQuery.Append(currentChar);
break;
}
pos++;
}
m_cmd.CommandText = rewrittenQuery.ToString();
m_cmd.Parameters.Clear();
if (m_positionalAttr)
{
// Mixed parameters not allowed
if (m_namedAttr)
{
m_pdo.HandleError(new PDOException("Mixed parameters mode not allowed. Use either only positional, or only named parameters."));
return(false);
}
foreach (var paramName in m_positionalPlaceholders.ToArray())
{
var param = m_cmd.CreateParameter();
param.ParameterName = paramName;
m_cmd.Parameters.Add(param);
}
}
else if (m_namedAttr)
{
foreach (var paramPair in m_namedPlaceholders)
{
var param = m_cmd.CreateParameter();
param.ParameterName = paramPair.Key;
m_cmd.Parameters.Add(param);
}
}
// Finalise the command preparation
m_cmd.Prepare();
return(true);
}