/// <summary>
/// Executes the given SQL character sequence directly,
/// returning a scalar value.
/// </summary>
/// <param name="sql">
/// The SQL character sequence to execute.
/// </param>
/// <returns>
/// A scalar value representing the result of the execution.
/// </returns>
internal object ExecuteScalarDirect(string sql)
{
Request request = s_protocol.CreateExecuteDirectRequest(sql);
s_protocol.SetMaxRows(request, 1);
Response response = Execute(request);
if (response.isUpdateCount() ||
0 >= response.getColumnCount() ||
response.isEmpty())
{
return(null);
}
object value = response.rRoot.data[0];
if (value == null)
{
return(null);
}
else if (value is string)
{
return(value);
}
else
{
int type = response.metaData.colTypes[0];
return(HsqlConvert.FromJava.ToObject(value, type));
}
}
public HsqlDataReader(org.hsqldb.Result result)
{
if (result == null)
{
throw new ArgumentNullException("result");
}
else if (result.isError())
{
throw new HsqlDataSourceException(result);
}
else if (result.isUpdateCount())
{
m_recordsAffected = result.getUpdateCount();
}
else if (result.isData())
{
m_recordsAffected = -1;
m_result = result;
m_fieldCount = result.getColumnCount();
m_metaData = result.metaData;
m_columnTypes = m_metaData.colTypes;
}
else
{
throw new InvalidOperationException(
"Unhandled Result Mode: " + result.mode);
}
}
/// <summary>
/// Executes the given prepared request, returning a scalar value.
/// </summary>
/// <param name="request">The prepared request.</param>
/// <returns>
/// The scalar value. This is the first column of first row;
/// <c>null</c> when the result has no columns or no rows.
/// </returns>
internal object ExecuteScalarPrepared(Request request)
{
s_protocol.SetMaxRows(request, 1);
Response response = Execute(request);
if (response.isUpdateCount() ||
(0 >= response.getColumnCount()) ||
response.isEmpty())
{
return(null);
}
// No check for null pointers or array bounds violation.
// We cannot get this far and still
// have a rRoot == null, rRoot.data == null or
// rRoot.data.Length < 1 condition, unless
// there is an actual (and serious) bug in the
// underlying libraries.
object value = response.rRoot.data[0];
if (value == null)
{
return(null);
}
else if (value is string)
{
return(value);
}
else
{
int type = response.metaData.colTypes[0];
return(HsqlConvert.FromJava.ToObject(value, type));
}
}
/// <summary>
/// Retrieves a <c>DataTable</c> object representing the column
/// metadata of the given data reader's current result.
/// </summary>
/// <param name="reader">
/// A reader object for which to retrieve the column metadata.
/// </param>
/// <returns>
/// A <c>DataTable</c> object representing the column metadata of the
/// given data reader's current result.
/// </returns>
/// <exception cref="HsqlDataSourceException">
/// If a data access error occurs.
/// </exception>
public static DataTable CreateSchemaTable(HsqlDataReader reader)
{
Result result = reader.m_result;
int columnCount = result.getColumnCount();
ResultMetaData metaData = result.metaData;
DataTable table = CreateTable(columnCount);
bool includeKeyInfo = reader.HasCommandBehavior(CommandBehavior.KeyInfo);
Dictionary <ColumnIdentifier, KeyInfo> keyInfoMap = (includeKeyInfo)
? HsqlResultSetMetaData.GetKeyInfo(reader)
: null;
string catalogName = reader.OriginatingConnection.Database;
for (int i = 0; i < columnCount; i++)
{
bool isAutoIncrement = metaData.isIdentity[i];
string columnName = metaData.colLabels[i];
int columnOrdinal = i;
int columnSize = metaData.colSizes[i];
int numericPrecision = metaData.colSizes[i];
int numericScale = metaData.colScales[i];
bool isUnique = false; // isAutoIncrement;
bool isKey = isAutoIncrement;
string baseServerName = null;
string baseCatalogName = catalogName;//metaData.catalogNames[i];
string baseColumnName = metaData.colNames[i];
string baseSchemaName = metaData.schemaNames[i];
string baseTableName = metaData.tableNames[i];
int providerType = metaData.colTypes[i];
Type dataType = HsqlConvert.ToDataType(providerType);
int nullability = metaData.colNullable[i];
bool allowDBNull = isAutoIncrement || (nullability != 0);
bool isAliased = (columnName != baseColumnName);
bool isExpression = string.IsNullOrEmpty(baseTableName);
bool isIdentity = isAutoIncrement;
bool isRowVersion = false;
bool isHidden = false;
bool isLong = HsqlConvert.ToIsLongProviderType(providerType);
bool isReadOnly = !metaData.isWritable[i];
if ((columnSize == 0) &&
HsqlTypes.isCharacterType(providerType))
{
columnSize = HsqlTypes.getPrecision(providerType);
}
if ((numericPrecision == 0) &&
HsqlTypes.isNumberType(providerType))
{
numericPrecision = HsqlTypes.getPrecision(providerType);
}
if (includeKeyInfo)
{
if (!(string.IsNullOrEmpty(baseTableName) ||
string.IsNullOrEmpty(baseColumnName)))
{
ColumnIdentifier key = new ColumnIdentifier(
baseSchemaName, baseTableName, baseColumnName);
KeyInfo keyInfo;
if (keyInfoMap.TryGetValue(key, out keyInfo))
{
isKey = keyInfo.m_isKey;
isUnique = keyInfo.m_isUnique;
}
}
}
HsqlResultSetMetaData.AddRow(table, columnName, columnOrdinal,
columnSize, numericPrecision, numericScale, isUnique,
isKey, baseServerName, baseCatalogName, baseColumnName,
baseSchemaName, baseTableName, dataType, allowDBNull,
providerType, isAliased, isExpression, isIdentity,
isAutoIncrement, isRowVersion, isHidden, isLong,
isReadOnly);
}
DataColumnCollection columns = table.Columns;
int count = columns.Count;
for (int i = 0; i < count; i++)
{
columns[i].ReadOnly = true;
}
return(table);
}
