public void ToParameterDirection()
{
Assert.AreEqual(ParameterDirection.Input, HsqlConvert.ToParameterDirection(ParameterMode.In));
Assert.AreEqual(ParameterDirection.InputOutput, HsqlConvert.ToParameterDirection(ParameterMode.InOut));
Assert.AreEqual(ParameterDirection.Output, HsqlConvert.ToParameterDirection(ParameterMode.Out));
Assert.AreEqual(null, HsqlConvert.ToParameterDirection(ParameterMode.Unknown));
}
public void ToProviderSpecificDataType()
{
Assert.AreEqual(typeof(java.sql.Array), HsqlConvert.ToProviderSpecificDataType(HsqlProviderType.Array));
Assert.AreEqual(typeof(java.lang.Long), HsqlConvert.ToProviderSpecificDataType(HsqlProviderType.BigInt));
Assert.AreEqual(typeof(org.hsqldb.types.Binary), HsqlConvert.ToProviderSpecificDataType(HsqlProviderType.Binary));
Assert.AreEqual(typeof(System.Data.Hsqldb.Common.Lob.IBlob), HsqlConvert.ToProviderSpecificDataType(HsqlProviderType.Blob));
Assert.AreEqual(typeof(java.lang.Boolean), HsqlConvert.ToProviderSpecificDataType(HsqlProviderType.Boolean));
Assert.AreEqual(typeof(string), HsqlConvert.ToProviderSpecificDataType(HsqlProviderType.Char));
Assert.AreEqual(typeof(System.Data.Hsqldb.Common.Lob.IClob), HsqlConvert.ToProviderSpecificDataType(HsqlProviderType.Clob));
Assert.AreEqual(typeof(java.net.URL), HsqlConvert.ToProviderSpecificDataType(HsqlProviderType.DataLink));
Assert.AreEqual(typeof(java.util.Date), HsqlConvert.ToProviderSpecificDataType(HsqlProviderType.Date));
Assert.AreEqual(typeof(java.math.BigDecimal), HsqlConvert.ToProviderSpecificDataType(HsqlProviderType.Decimal));
Assert.AreEqual(typeof(object), HsqlConvert.ToProviderSpecificDataType(HsqlProviderType.Distinct));
Assert.AreEqual(typeof(java.lang.Double), HsqlConvert.ToProviderSpecificDataType(HsqlProviderType.Double));
Assert.AreEqual(typeof(java.lang.Double), HsqlConvert.ToProviderSpecificDataType(HsqlProviderType.Float));
Assert.AreEqual(typeof(java.lang.Integer), HsqlConvert.ToProviderSpecificDataType(HsqlProviderType.Integer));
Assert.AreEqual(typeof(org.hsqldb.types.JavaObject), HsqlConvert.ToProviderSpecificDataType(HsqlProviderType.JavaObject));
Assert.AreEqual(typeof(org.hsqldb.types.Binary), HsqlConvert.ToProviderSpecificDataType(HsqlProviderType.LongVarBinary));
Assert.AreEqual(typeof(string), HsqlConvert.ToProviderSpecificDataType(HsqlProviderType.LongVarChar));
Assert.AreEqual(typeof(void), HsqlConvert.ToProviderSpecificDataType(HsqlProviderType.Null));
Assert.AreEqual(typeof(java.math.BigDecimal), HsqlConvert.ToProviderSpecificDataType(HsqlProviderType.Numeric));
Assert.AreEqual(typeof(System.Data.Hsqldb.Common.Sql.Types.SqlObject), HsqlConvert.ToProviderSpecificDataType(HsqlProviderType.Object));
Assert.AreEqual(typeof(java.lang.Double), HsqlConvert.ToProviderSpecificDataType(HsqlProviderType.Real));
Assert.AreEqual(typeof(java.sql.Ref), HsqlConvert.ToProviderSpecificDataType(HsqlProviderType.Ref));
Assert.AreEqual(typeof(java.lang.Integer), HsqlConvert.ToProviderSpecificDataType(HsqlProviderType.SmallInt));
Assert.AreEqual(typeof(java.sql.Struct), HsqlConvert.ToProviderSpecificDataType(HsqlProviderType.Struct));
Assert.AreEqual(typeof(java.sql.Time), HsqlConvert.ToProviderSpecificDataType(HsqlProviderType.Time));
Assert.AreEqual(typeof(java.sql.Timestamp), HsqlConvert.ToProviderSpecificDataType(HsqlProviderType.TimeStamp));
Assert.AreEqual(typeof(java.lang.Integer), HsqlConvert.ToProviderSpecificDataType(HsqlProviderType.TinyInt));
Assert.AreEqual(typeof(org.hsqldb.types.Binary), HsqlConvert.ToProviderSpecificDataType(HsqlProviderType.VarBinary));
Assert.AreEqual(typeof(string), HsqlConvert.ToProviderSpecificDataType(HsqlProviderType.VarChar));
Assert.AreEqual(typeof(string), HsqlConvert.ToProviderSpecificDataType(org.hsqldb.Types.VARCHAR_IGNORECASE));
Assert.AreEqual(typeof(java.sql.SQLXML), HsqlConvert.ToProviderSpecificDataType(HsqlProviderType.Xml));
}
public void ToDataType()
{
Assert.AreEqual(typeof(object), HsqlConvert.ToDataType(HsqlProviderType.Array));
Assert.AreEqual(typeof(long), HsqlConvert.ToDataType(HsqlProviderType.BigInt));
Assert.AreEqual(typeof(byte[]), HsqlConvert.ToDataType(HsqlProviderType.Binary));
Assert.AreEqual(typeof(object), HsqlConvert.ToDataType(HsqlProviderType.Blob));
Assert.AreEqual(typeof(bool), HsqlConvert.ToDataType(HsqlProviderType.Boolean));
Assert.AreEqual(typeof(string), HsqlConvert.ToDataType(HsqlProviderType.Char));
Assert.AreEqual(typeof(object), HsqlConvert.ToDataType(HsqlProviderType.Clob));
Assert.AreEqual(typeof(object), HsqlConvert.ToDataType(HsqlProviderType.DataLink));
Assert.AreEqual(typeof(DateTime), HsqlConvert.ToDataType(HsqlProviderType.Date));
Assert.AreEqual(typeof(decimal), HsqlConvert.ToDataType(HsqlProviderType.Decimal));
Assert.AreEqual(typeof(object), HsqlConvert.ToDataType(HsqlProviderType.Distinct));
Assert.AreEqual(typeof(double), HsqlConvert.ToDataType(HsqlProviderType.Double));
Assert.AreEqual(typeof(double), HsqlConvert.ToDataType(HsqlProviderType.Float));
Assert.AreEqual(typeof(int), HsqlConvert.ToDataType(HsqlProviderType.Integer));
Assert.AreEqual(typeof(object), HsqlConvert.ToDataType(HsqlProviderType.JavaObject));
Assert.AreEqual(typeof(byte[]), HsqlConvert.ToDataType(HsqlProviderType.LongVarBinary));
Assert.AreEqual(typeof(string), HsqlConvert.ToDataType(HsqlProviderType.LongVarChar));
Assert.AreEqual(typeof(object), HsqlConvert.ToDataType(HsqlProviderType.Null));
Assert.AreEqual(typeof(decimal), HsqlConvert.ToDataType(HsqlProviderType.Numeric));
Assert.AreEqual(typeof(object), HsqlConvert.ToDataType(HsqlProviderType.Object));
Assert.AreEqual(typeof(float), HsqlConvert.ToDataType(HsqlProviderType.Real));
Assert.AreEqual(typeof(object), HsqlConvert.ToDataType(HsqlProviderType.Ref));
Assert.AreEqual(typeof(short), HsqlConvert.ToDataType(HsqlProviderType.SmallInt));
Assert.AreEqual(typeof(object), HsqlConvert.ToDataType(HsqlProviderType.Struct));
Assert.AreEqual(typeof(DateTime), HsqlConvert.ToDataType(HsqlProviderType.Time));
Assert.AreEqual(typeof(DateTime), HsqlConvert.ToDataType(HsqlProviderType.TimeStamp));
Assert.AreEqual(typeof(sbyte), HsqlConvert.ToDataType(HsqlProviderType.TinyInt));
Assert.AreEqual(typeof(byte[]), HsqlConvert.ToDataType(HsqlProviderType.VarBinary));
Assert.AreEqual(typeof(string), HsqlConvert.ToDataType(HsqlProviderType.VarChar));
Assert.AreEqual(typeof(string), HsqlConvert.ToDataType(HsqlProviderType.Xml));
}
public void ToHsqlProviderType()
{
Assert.AreEqual(HsqlProviderType.VarChar, HsqlConvert.ToHsqlProviderType(DbType.AnsiString));
Assert.AreEqual(HsqlProviderType.Char, HsqlConvert.ToHsqlProviderType(DbType.AnsiStringFixedLength));
Assert.AreEqual(HsqlProviderType.Binary, HsqlConvert.ToHsqlProviderType(DbType.Binary));
Assert.AreEqual(HsqlProviderType.Boolean, HsqlConvert.ToHsqlProviderType(DbType.Boolean));
Assert.AreEqual(HsqlProviderType.SmallInt, HsqlConvert.ToHsqlProviderType(DbType.Byte));
Assert.AreEqual(HsqlProviderType.Decimal, HsqlConvert.ToHsqlProviderType(DbType.Currency));
Assert.AreEqual(HsqlProviderType.TimeStamp, HsqlConvert.ToHsqlProviderType(DbType.Date));
Assert.AreEqual(HsqlProviderType.TimeStamp, HsqlConvert.ToHsqlProviderType(DbType.DateTime));
Assert.AreEqual(HsqlProviderType.TimeStamp, HsqlConvert.ToHsqlProviderType(DbType.DateTime2));
Assert.AreEqual(HsqlProviderType.Char, HsqlConvert.ToHsqlProviderType(DbType.DateTimeOffset));
Assert.AreEqual(HsqlProviderType.Decimal, HsqlConvert.ToHsqlProviderType(DbType.Decimal));
Assert.AreEqual(HsqlProviderType.Double, HsqlConvert.ToHsqlProviderType(DbType.Double));
Assert.AreEqual(HsqlProviderType.Binary, HsqlConvert.ToHsqlProviderType(DbType.Guid));
Assert.AreEqual(HsqlProviderType.SmallInt, HsqlConvert.ToHsqlProviderType(DbType.Int16));
Assert.AreEqual(HsqlProviderType.Integer, HsqlConvert.ToHsqlProviderType(DbType.Int32));
Assert.AreEqual(HsqlProviderType.BigInt, HsqlConvert.ToHsqlProviderType(DbType.Int64));
Assert.AreEqual(HsqlProviderType.Object, HsqlConvert.ToHsqlProviderType(DbType.Object));
Assert.AreEqual(HsqlProviderType.TinyInt, HsqlConvert.ToHsqlProviderType(DbType.SByte));
Assert.AreEqual(HsqlProviderType.Real, HsqlConvert.ToHsqlProviderType(DbType.Single));
Assert.AreEqual(HsqlProviderType.VarChar, HsqlConvert.ToHsqlProviderType(DbType.String));
Assert.AreEqual(HsqlProviderType.Char, HsqlConvert.ToHsqlProviderType(DbType.StringFixedLength));
Assert.AreEqual(HsqlProviderType.TimeStamp, HsqlConvert.ToHsqlProviderType(DbType.Time));
Assert.AreEqual(HsqlProviderType.Integer, HsqlConvert.ToHsqlProviderType(DbType.UInt16));
Assert.AreEqual(HsqlProviderType.BigInt, HsqlConvert.ToHsqlProviderType(DbType.UInt32));
Assert.AreEqual(HsqlProviderType.Numeric, HsqlConvert.ToHsqlProviderType(DbType.UInt64));
Assert.AreEqual(HsqlProviderType.Numeric, HsqlConvert.ToHsqlProviderType(DbType.VarNumeric));
Assert.AreEqual(HsqlProviderType.Xml, HsqlConvert.ToHsqlProviderType(DbType.Xml));
}
public void ToHsqlIsolationLevel()
{
Assert.AreEqual(HsqlIsolationLevel.ReadCommited, HsqlConvert.ToHsqlIsolationLevel(IsolationLevel.ReadCommitted));
Assert.AreEqual(HsqlIsolationLevel.ReadCommited, HsqlConvert.ToHsqlIsolationLevel(IsolationLevel.Unspecified));
//
Assert.AreEqual(HsqlIsolationLevel.ReadUncommited, HsqlConvert.ToHsqlIsolationLevel(IsolationLevel.ReadUncommitted));
Assert.AreEqual(HsqlIsolationLevel.RepeatableRead, HsqlConvert.ToHsqlIsolationLevel(IsolationLevel.RepeatableRead));
Assert.AreEqual(HsqlIsolationLevel.Serializable, HsqlConvert.ToHsqlIsolationLevel(IsolationLevel.Serializable));
try
{
HsqlIsolationLevel actual = HsqlConvert.ToHsqlIsolationLevel(IsolationLevel.Chaos);
Assert.Fail("There is no HsqlIsolationLevel corresponding to IsolationLevel.Chaos");
}
catch (ArgumentException ae)
{
Assert.AreEqual("isolationLevel", ae.ParamName);
Assert.AreEqual("Unsupported Level: Chaos" + Environment.NewLine + "Parameter name: isolationLevel", ae.Message);
}
try
{
HsqlIsolationLevel actual = HsqlConvert.ToHsqlIsolationLevel(IsolationLevel.Snapshot);
Assert.Fail("There is no HsqlIsolationLevel corresponding to IsolationLevel.Snapshot");
}
catch (ArgumentException ae)
{
Assert.AreEqual("isolationLevel", ae.ParamName);
Assert.AreEqual("Unsupported Level: Snapshot" + Environment.NewLine + "Parameter name: isolationLevel", ae.Message);
}
}
public void ToDbType()
{
Assert.AreEqual(DbType.Object, HsqlConvert.ToDbType(HsqlProviderType.Array));
Assert.AreEqual(DbType.Int64, HsqlConvert.ToDbType(HsqlProviderType.BigInt));
Assert.AreEqual(DbType.Binary, HsqlConvert.ToDbType(HsqlProviderType.Binary));
Assert.AreEqual(DbType.Object, HsqlConvert.ToDbType(HsqlProviderType.Blob));
Assert.AreEqual(DbType.Boolean, HsqlConvert.ToDbType(HsqlProviderType.Boolean));
Assert.AreEqual(DbType.StringFixedLength, HsqlConvert.ToDbType(HsqlProviderType.Char));
Assert.AreEqual(DbType.Object, HsqlConvert.ToDbType(HsqlProviderType.Clob));
Assert.AreEqual(DbType.Object, HsqlConvert.ToDbType(HsqlProviderType.DataLink));
Assert.AreEqual(DbType.DateTime, HsqlConvert.ToDbType(HsqlProviderType.Date));
Assert.AreEqual(DbType.Decimal, HsqlConvert.ToDbType(HsqlProviderType.Decimal));
Assert.AreEqual(DbType.Object, HsqlConvert.ToDbType(HsqlProviderType.Distinct));
Assert.AreEqual(DbType.Double, HsqlConvert.ToDbType(HsqlProviderType.Double));
Assert.AreEqual(DbType.Double, HsqlConvert.ToDbType(HsqlProviderType.Float));
Assert.AreEqual(DbType.Int32, HsqlConvert.ToDbType(HsqlProviderType.Integer));
Assert.AreEqual(DbType.Object, HsqlConvert.ToDbType(HsqlProviderType.JavaObject));
Assert.AreEqual(DbType.Object, HsqlConvert.ToDbType(HsqlProviderType.LongVarBinary));
Assert.AreEqual(DbType.String, HsqlConvert.ToDbType(HsqlProviderType.LongVarChar));
Assert.AreEqual(DbType.Object, HsqlConvert.ToDbType(HsqlProviderType.Null));
Assert.AreEqual(DbType.VarNumeric, HsqlConvert.ToDbType(HsqlProviderType.Numeric));
Assert.AreEqual(DbType.Object, HsqlConvert.ToDbType(HsqlProviderType.Object));
Assert.AreEqual(DbType.Single, HsqlConvert.ToDbType(HsqlProviderType.Real));
Assert.AreEqual(DbType.Object, HsqlConvert.ToDbType(HsqlProviderType.Ref));
Assert.AreEqual(DbType.Int16, HsqlConvert.ToDbType(HsqlProviderType.SmallInt));
Assert.AreEqual(DbType.Object, HsqlConvert.ToDbType(HsqlProviderType.Struct));
Assert.AreEqual(DbType.DateTime, HsqlConvert.ToDbType(HsqlProviderType.Time));
Assert.AreEqual(DbType.DateTime2, HsqlConvert.ToDbType(HsqlProviderType.TimeStamp));
Assert.AreEqual(DbType.SByte, HsqlConvert.ToDbType(HsqlProviderType.TinyInt));
Assert.AreEqual(DbType.Object, HsqlConvert.ToDbType(HsqlProviderType.VarBinary));
Assert.AreEqual(DbType.String, HsqlConvert.ToDbType(HsqlProviderType.VarChar));
Assert.AreEqual(DbType.Xml, HsqlConvert.ToDbType(HsqlProviderType.Xml));
}
public void ToIsolationLevel()
{
Assert.AreEqual(IsolationLevel.Unspecified, HsqlConvert.ToIsolationLevel(HsqlIsolationLevel.None));
Assert.AreEqual(IsolationLevel.ReadCommitted, HsqlConvert.ToIsolationLevel(HsqlIsolationLevel.ReadCommited));
Assert.AreEqual(IsolationLevel.ReadUncommitted, HsqlConvert.ToIsolationLevel(HsqlIsolationLevel.ReadUncommited));
Assert.AreEqual(IsolationLevel.RepeatableRead, HsqlConvert.ToIsolationLevel(HsqlIsolationLevel.RepeatableRead));
Assert.AreEqual(IsolationLevel.Serializable, HsqlConvert.ToIsolationLevel(HsqlIsolationLevel.Serializable));
}
public void InvalidConversion()
{
try
{
throw HsqlConvert.InvalidConversion(java.sql.Types.DATALINK);
}
catch (HsqlDataSourceException hdse)
{
Assert.AreEqual(org.hsqldb.Trace.INVALID_CONVERSION, -hdse.ErrorCode);
}
}
/// <summary>
/// Fills a <c>DataTypes</c> metadata collection table
/// using the given connection and restrictions.
/// </summary>
/// <param name="connection">The connection from which to fill the table.</param>
/// <param name="table">The table to file.</param>
/// <param name="restrictions">The restrictions.</param>
public override void FillTable(HsqlConnection connection,
DataTable table, string[] restrictions)
{
using (HsqlDataReader reader = Execute(connection, sql))
{
object[] values = new object[reader.FieldCount];
while (reader.Read())
{
reader.GetValues(values);
string providerTypeName = (string)values[0];
int providerDbType = (int)values[1];
int? columnSize = (int?)values[2];
string literalPrefix = (string)values[3];
string literalSuffix = (string)values[4];
string createParameters = (string)values[5];
short nullability = (short)(int)values[6];
bool? isCaseSensitive = (bool?)values[7];
short searchability = (short)(int)values[8];
bool? isUnsigned = (bool?)values[9];
bool? isFixedPrecisionScale = (bool?)values[10];
bool? isAutoIncrementable = (bool?)values[11];
//string localTypeName = (string) values[12];
short?minimumScale = (short?)(int?)values[13];
short?maximumScale = (short?)(int?)values[14];
//int? sqlDataType = (int?) values[15];
//int? dateTimeSub = (int?)values[16];
//int? numPrecRadix = (int?)values[17];
//int? typeSub = (int?)values[18];
string createFormat = ToCreateFormat(providerTypeName, createParameters);
string dataType = Convert.ToString(HsqlConvert.ToDataType(providerDbType));
bool isBestMatch = IsBestMatchProviderTypeName(providerTypeName);
bool isFixedLength = IsFixedLength(providerDbType);
bool isLong = IsLongProviderType(providerDbType);
bool isNullable = IsNullable(nullability);
bool isSearchable = IsSearchable(searchability);
bool isSearchableWithLike = IsSearchableWithLike(searchability);
bool isConcurrencyType = false;
bool isLiteralSupported = true;
AddRow(table,
providerTypeName, providerDbType,
columnSize,
createFormat, createParameters,
dataType, isAutoIncrementable, isBestMatch,
isCaseSensitive, isFixedLength, isFixedPrecisionScale, isLong,
isNullable, isSearchable, isSearchableWithLike, isUnsigned,
maximumScale, minimumScale, isConcurrencyType,
isLiteralSupported, literalPrefix, literalSuffix);
}
}
}
public void WrongDataType()
{
object o = new object();
try
{
throw HsqlConvert.WrongDataType(o);
}
catch (HsqlDataSourceException hdse)
{
Assert.AreEqual(org.hsqldb.Trace.WRONG_DATA_TYPE, -hdse.ErrorCode);
}
}
public void NumericValueOutOfRange()
{
object n = 42L;
try
{
throw HsqlConvert.NumericValueOutOfRange(n);
}
catch (HsqlDataSourceException hdse)
{
Assert.AreEqual(org.hsqldb.Trace.NUMERIC_VALUE_OUT_OF_RANGE, -hdse.ErrorCode);
}
}
public void UnknownConversion()
{
object o = new object();
int targetType = java.sql.Types.BIGINT;
try
{
throw HsqlConvert.UnknownConversion(o, targetType);
}
catch (HsqlDataSourceException hdse)
{
Assert.AreEqual(org.hsqldb.Trace.INVALID_CONVERSION, -hdse.ErrorCode);
}
}
public override void EnlistTransaction(Transaction systemTransaction)
{
lock (m_syncRoot)
{
CheckClosed();
if (systemTransaction == null)
{
throw new ArgumentNullException("transaction");
}
HsqlEnlistment enlistment = m_enlistment;
if (enlistment == null)
{
enlistment = new HsqlEnlistment(this, systemTransaction);
if (!systemTransaction.EnlistPromotableSinglePhase(enlistment))
{
if (m_transaction == null)
{
BeginTransaction(HsqlConvert.ToIsolationLevel(systemTransaction.IsolationLevel));
}
enlistment.m_dbTransaction = m_transaction;
systemTransaction.EnlistDurable(enlistment.Rmid, enlistment, EnlistmentOptions.None);
}
m_enlistment = enlistment;
GC.KeepAlive(this);
}
else if (enlistment.Transaction != systemTransaction)
{
throw new InvalidOperationException(
"Connection currently has transaction enlisted."
+ " Finish current transaction and retry."); // NOI18N
}
}
}
public void ToSqlLiteral()
{
// FIX LENGTH CUTOVER
//
// 1..255 : CHAR
// 256..2000 : VARCHAR
// > 2000 : LONGVARCHAR
// VARIABLE LENGTH CUTOVER
//
// 1..2000 : VARCHAR
// > 2000 : LONGVARCHAR
string shortCharSequence = "foo";
string medCharSequence = "0123456789";
medCharSequence += medCharSequence; // 20
medCharSequence += medCharSequence; // 40
medCharSequence += medCharSequence; // 80
medCharSequence += medCharSequence; // 160
medCharSequence += medCharSequence; // 320
string longCharSequence = medCharSequence;
longCharSequence += longCharSequence; // 640
longCharSequence += longCharSequence; // 1280
longCharSequence += longCharSequence; // 2560
Assert.AreEqual(string.Format("CAST('{0}' AS CHAR(3))", shortCharSequence), HsqlConvert.ToSqlLiteral(new FakeDataParameter(DbType.AnsiStringFixedLength, shortCharSequence)));
Assert.AreEqual(string.Format("CAST('{0}' AS CHAR(3))", shortCharSequence), HsqlConvert.ToSqlLiteral(new FakeDataParameter(DbType.StringFixedLength, shortCharSequence)));
Assert.AreEqual(string.Format("CAST('{0}' AS VARCHAR(3))", shortCharSequence), HsqlConvert.ToSqlLiteral(new FakeDataParameter(DbType.AnsiString, shortCharSequence)));
Assert.AreEqual(string.Format("CAST('{0}' AS VARCHAR(3))", shortCharSequence), HsqlConvert.ToSqlLiteral(new FakeDataParameter(DbType.String, shortCharSequence)));
//--
Assert.AreEqual(string.Format("CAST('{0}' AS VARCHAR(320))", medCharSequence), HsqlConvert.ToSqlLiteral(new FakeDataParameter(DbType.AnsiStringFixedLength, medCharSequence)));
Assert.AreEqual(string.Format("CAST('{0}' AS VARCHAR(320))", medCharSequence), HsqlConvert.ToSqlLiteral(new FakeDataParameter(DbType.StringFixedLength, medCharSequence)));
Assert.AreEqual(string.Format("CAST('{0}' AS VARCHAR(320))", medCharSequence), HsqlConvert.ToSqlLiteral(new FakeDataParameter(DbType.AnsiString, medCharSequence)));
Assert.AreEqual(string.Format("CAST('{0}' AS VARCHAR(320))", medCharSequence), HsqlConvert.ToSqlLiteral(new FakeDataParameter(DbType.String, medCharSequence)));
//--
//--
Assert.AreEqual(string.Format("CAST('{0}' AS LONGVARCHAR)", longCharSequence), HsqlConvert.ToSqlLiteral(new FakeDataParameter(DbType.AnsiStringFixedLength, longCharSequence)));
Assert.AreEqual(string.Format("CAST('{0}' AS LONGVARCHAR)", longCharSequence), HsqlConvert.ToSqlLiteral(new FakeDataParameter(DbType.StringFixedLength, longCharSequence)));
Assert.AreEqual(string.Format("CAST('{0}' AS LONGVARCHAR)", longCharSequence), HsqlConvert.ToSqlLiteral(new FakeDataParameter(DbType.AnsiString, longCharSequence)));
Assert.AreEqual(string.Format("CAST('{0}' AS LONGVARCHAR)", longCharSequence), HsqlConvert.ToSqlLiteral(new FakeDataParameter(DbType.String, longCharSequence)));
//--
// BINARY LENGTH CUTOVER
// 1..255 : BINARY
// 256..4000 : VARBINARY
// > 4000 : LONGVARBINARY
byte[] shortBinary = new byte[] {
(byte)1, (byte)35, (byte)69, (byte)103, (byte)137, (byte)171, (byte)205, (byte)239
};
string shortBinaryString = "0123456789abcdef";
byte[] medBinary = (new SqlBinary(shortBinary) + new SqlBinary(shortBinary)).Value; // 16
medBinary = (new SqlBinary(medBinary) + new SqlBinary(medBinary)).Value; // 32
medBinary = (new SqlBinary(medBinary) + new SqlBinary(medBinary)).Value; // 64
medBinary = (new SqlBinary(medBinary) + new SqlBinary(medBinary)).Value; // 128
medBinary = (new SqlBinary(medBinary) + new SqlBinary(medBinary)).Value; // 256
string medBinaryString = shortBinaryString + shortBinaryString; //16
medBinaryString += medBinaryString; // 32
medBinaryString += medBinaryString; // 64
medBinaryString += medBinaryString; // 128
medBinaryString += medBinaryString; // 256
byte[] longBinary = (new SqlBinary(medBinary) + new SqlBinary(medBinary)).Value; // 512
longBinary = (new SqlBinary(longBinary) + new SqlBinary(longBinary)).Value; // 1024
longBinary = (new SqlBinary(longBinary) + new SqlBinary(longBinary)).Value; // 2048
longBinary = (new SqlBinary(longBinary) + new SqlBinary(longBinary)).Value; // 4096
string longBinaryString = medBinaryString + medBinaryString; // 512
longBinaryString += longBinaryString; // 1024
longBinaryString += longBinaryString; // 2048
longBinaryString += longBinaryString; // 4096
//--
Assert.AreEqual(string.Format("CAST('{0}' AS BINARY(8))", shortBinaryString), HsqlConvert.ToSqlLiteral(new FakeDataParameter(DbType.Binary, shortBinary)));
Assert.AreEqual(string.Format("CAST('{0}' AS BINARY(8))", shortBinaryString), HsqlConvert.ToSqlLiteral(new FakeDataParameter(DbType.Binary, shortBinaryString)));
//--
Assert.AreEqual(string.Format("CAST('{0}' AS VARBINARY(256))", medBinaryString), HsqlConvert.ToSqlLiteral(new FakeDataParameter(DbType.Binary, medBinary)));
Assert.AreEqual(string.Format("CAST('{0}' AS VARBINARY(256))", medBinaryString), HsqlConvert.ToSqlLiteral(new FakeDataParameter(DbType.Binary, medBinaryString)));
//--
Assert.AreEqual(string.Format("CAST('{0}' AS LONGVARBINARY)", longBinaryString), HsqlConvert.ToSqlLiteral(new FakeDataParameter(DbType.Binary, longBinary)));
Assert.AreEqual(string.Format("CAST('{0}' AS LONGVARBINARY)", longBinaryString), HsqlConvert.ToSqlLiteral(new FakeDataParameter(DbType.Binary, longBinaryString)));
//
long longBits = java.lang.Double.doubleToRawLongBits(123456789.987654321D);
byte[] longBytes = new byte[]
{
(byte)((longBits >> 56) & 0xff),
(byte)((longBits >> 48) & 0xff),
(byte)((longBits >> 40) & 0xff),
(byte)((longBits >> 32) & 0xff),
(byte)((longBits >> 24) & 0xff),
(byte)((longBits >> 16) & 0xff),
(byte)((longBits >> 8) & 0xff),
(byte)((longBits >> 0) & 0xff)
};
Assert.AreEqual("CAST('419d6f3457f35ba8' AS BINARY(8))", HsqlConvert.ToSqlLiteral(new FakeDataParameter(DbType.Binary, longBytes)));
Assert.AreEqual("CAST('419d6f3457f35ba8' AS BINARY(8))", HsqlConvert.ToSqlLiteral(new FakeDataParameter(DbType.Binary, longBits)));
Assert.AreEqual("CAST('419d6f3457f35ba8' AS BINARY(8))", HsqlConvert.ToSqlLiteral(new FakeDataParameter(DbType.Binary, 123456789.987654321D)));
int intBits = java.lang.Float.floatToRawIntBits(123456789.987654321F);
byte[] intBytes = new byte[]
{
(byte)((intBits >> 24) & 0xff),
(byte)((intBits >> 16) & 0xff),
(byte)((intBits >> 8) & 0xff),
(byte)((intBits >> 0) & 0xff)
};
Assert.AreEqual("CAST('4ceb79a3' AS BINARY(4))", HsqlConvert.ToSqlLiteral(new FakeDataParameter(DbType.Binary, intBits)));
Assert.AreEqual("CAST('4ceb79a3' AS BINARY(4))", HsqlConvert.ToSqlLiteral(new FakeDataParameter(DbType.Binary, intBytes)));
Assert.AreEqual("CAST('4ceb79a3' AS BINARY(4))", HsqlConvert.ToSqlLiteral(new FakeDataParameter(DbType.Binary, 123456789.987654321F)));
Assert.AreEqual("CAST('ffffffffffffffffffffffff00000000' AS BINARY(16))", HsqlConvert.ToSqlLiteral(new FakeDataParameter(DbType.Binary, decimal.MaxValue)));
Assert.AreEqual("CAST('ffffffffffffffffffffffff80000000' AS BINARY(16))", HsqlConvert.ToSqlLiteral(new FakeDataParameter(DbType.Binary, decimal.MinValue)));
Assert.AreEqual("CAST('00' AS BINARY(1))", HsqlConvert.ToSqlLiteral(new FakeDataParameter(DbType.Binary, (sbyte)0)));
Assert.AreEqual("CAST('01' AS BINARY(1))", HsqlConvert.ToSqlLiteral(new FakeDataParameter(DbType.Binary, (sbyte)1)));
Assert.AreEqual("CAST('80' AS BINARY(1))", HsqlConvert.ToSqlLiteral(new FakeDataParameter(DbType.Binary, sbyte.MinValue)));
Assert.AreEqual("CAST('7f' AS BINARY(1))", HsqlConvert.ToSqlLiteral(new FakeDataParameter(DbType.Binary, sbyte.MaxValue)));
Assert.AreEqual("CAST('00' AS BINARY(1))", HsqlConvert.ToSqlLiteral(new FakeDataParameter(DbType.Binary, (byte)0)));
Assert.AreEqual("CAST('01' AS BINARY(1))", HsqlConvert.ToSqlLiteral(new FakeDataParameter(DbType.Binary, (byte)1)));
Assert.AreEqual("CAST('00' AS BINARY(1))", HsqlConvert.ToSqlLiteral(new FakeDataParameter(DbType.Binary, byte.MinValue)));
Assert.AreEqual("CAST('ff' AS BINARY(1))", HsqlConvert.ToSqlLiteral(new FakeDataParameter(DbType.Binary, byte.MaxValue)));
Assert.AreEqual("CAST('0000' AS BINARY(2))", HsqlConvert.ToSqlLiteral(new FakeDataParameter(DbType.Binary, (char)0)));
Assert.AreEqual("CAST('0001' AS BINARY(2))", HsqlConvert.ToSqlLiteral(new FakeDataParameter(DbType.Binary, (char)1)));
Assert.AreEqual("CAST('0000' AS BINARY(2))", HsqlConvert.ToSqlLiteral(new FakeDataParameter(DbType.Binary, char.MinValue)));
Assert.AreEqual("CAST('ffff' AS BINARY(2))", HsqlConvert.ToSqlLiteral(new FakeDataParameter(DbType.Binary, char.MaxValue)));
Assert.AreEqual("CAST('0000' AS BINARY(2))", HsqlConvert.ToSqlLiteral(new FakeDataParameter(DbType.Binary, (short)0)));
Assert.AreEqual("CAST('0001' AS BINARY(2))", HsqlConvert.ToSqlLiteral(new FakeDataParameter(DbType.Binary, (short)1)));
Assert.AreEqual("CAST('8000' AS BINARY(2))", HsqlConvert.ToSqlLiteral(new FakeDataParameter(DbType.Binary, short.MinValue)));
Assert.AreEqual("CAST('7fff' AS BINARY(2))", HsqlConvert.ToSqlLiteral(new FakeDataParameter(DbType.Binary, short.MaxValue)));
Assert.AreEqual("CAST('0000' AS BINARY(2))", HsqlConvert.ToSqlLiteral(new FakeDataParameter(DbType.Binary, (ushort)0)));
Assert.AreEqual("CAST('0001' AS BINARY(2))", HsqlConvert.ToSqlLiteral(new FakeDataParameter(DbType.Binary, (ushort)1)));
Assert.AreEqual("CAST('0000' AS BINARY(2))", HsqlConvert.ToSqlLiteral(new FakeDataParameter(DbType.Binary, ushort.MinValue)));
Assert.AreEqual("CAST('ffff' AS BINARY(2))", HsqlConvert.ToSqlLiteral(new FakeDataParameter(DbType.Binary, ushort.MaxValue)));
Assert.AreEqual("CAST('00000000' AS BINARY(4))", HsqlConvert.ToSqlLiteral(new FakeDataParameter(DbType.Binary, (int)0)));
Assert.AreEqual("CAST('00000001' AS BINARY(4))", HsqlConvert.ToSqlLiteral(new FakeDataParameter(DbType.Binary, (int)1)));
Assert.AreEqual("CAST('80000000' AS BINARY(4))", HsqlConvert.ToSqlLiteral(new FakeDataParameter(DbType.Binary, int.MinValue)));
Assert.AreEqual("CAST('7fffffff' AS BINARY(4))", HsqlConvert.ToSqlLiteral(new FakeDataParameter(DbType.Binary, int.MaxValue)));
Assert.AreEqual("CAST('00000000' AS BINARY(4))", HsqlConvert.ToSqlLiteral(new FakeDataParameter(DbType.Binary, (uint)0)));
Assert.AreEqual("CAST('00000001' AS BINARY(4))", HsqlConvert.ToSqlLiteral(new FakeDataParameter(DbType.Binary, (uint)1)));
Assert.AreEqual("CAST('00000000' AS BINARY(4))", HsqlConvert.ToSqlLiteral(new FakeDataParameter(DbType.Binary, uint.MinValue)));
Assert.AreEqual("CAST('ffffffff' AS BINARY(4))", HsqlConvert.ToSqlLiteral(new FakeDataParameter(DbType.Binary, uint.MaxValue)));
Assert.AreEqual("CAST('0000000000000000' AS BINARY(8))", HsqlConvert.ToSqlLiteral(new FakeDataParameter(DbType.Binary, (long)0)));
Assert.AreEqual("CAST('0000000000000001' AS BINARY(8))", HsqlConvert.ToSqlLiteral(new FakeDataParameter(DbType.Binary, (long)1)));
Assert.AreEqual("CAST('8000000000000000' AS BINARY(8))", HsqlConvert.ToSqlLiteral(new FakeDataParameter(DbType.Binary, long.MinValue)));
Assert.AreEqual("CAST('7fffffffffffffff' AS BINARY(8))", HsqlConvert.ToSqlLiteral(new FakeDataParameter(DbType.Binary, long.MaxValue)));
Assert.AreEqual("CAST('0000000000000000' AS BINARY(8))", HsqlConvert.ToSqlLiteral(new FakeDataParameter(DbType.Binary, (ulong)0)));
Assert.AreEqual("CAST('0000000000000001' AS BINARY(8))", HsqlConvert.ToSqlLiteral(new FakeDataParameter(DbType.Binary, (ulong)1)));
Assert.AreEqual("CAST('0000000000000000' AS BINARY(8))", HsqlConvert.ToSqlLiteral(new FakeDataParameter(DbType.Binary, ulong.MinValue)));
Assert.AreEqual("CAST('ffffffffffffffff' AS BINARY(8))", HsqlConvert.ToSqlLiteral(new FakeDataParameter(DbType.Binary, ulong.MaxValue)));
//--
Assert.AreEqual("CAST((1=0) AS BOOLEAN)", HsqlConvert.ToSqlLiteral(new FakeDataParameter(DbType.Boolean, false)));
Assert.AreEqual("CAST((1=0) AS BOOLEAN)", HsqlConvert.ToSqlLiteral(new FakeDataParameter(DbType.Boolean, "frue"))); // ... ;-)
Assert.AreEqual("CAST((1=0) AS BOOLEAN)", HsqlConvert.ToSqlLiteral(new FakeDataParameter(DbType.Boolean, (sbyte)0)));
Assert.AreEqual("CAST((1=0) AS BOOLEAN)", HsqlConvert.ToSqlLiteral(new FakeDataParameter(DbType.Boolean, (byte)0)));
Assert.AreEqual("CAST((1=0) AS BOOLEAN)", HsqlConvert.ToSqlLiteral(new FakeDataParameter(DbType.Boolean, (char)0)));
Assert.AreEqual("CAST((1=0) AS BOOLEAN)", HsqlConvert.ToSqlLiteral(new FakeDataParameter(DbType.Boolean, (char)'0')));
Assert.AreEqual("CAST((1=0) AS BOOLEAN)", HsqlConvert.ToSqlLiteral(new FakeDataParameter(DbType.Boolean, (short)0)));
Assert.AreEqual("CAST((1=0) AS BOOLEAN)", HsqlConvert.ToSqlLiteral(new FakeDataParameter(DbType.Boolean, (ushort)0)));
Assert.AreEqual("CAST((1=0) AS BOOLEAN)", HsqlConvert.ToSqlLiteral(new FakeDataParameter(DbType.Boolean, (int)0)));
Assert.AreEqual("CAST((1=0) AS BOOLEAN)", HsqlConvert.ToSqlLiteral(new FakeDataParameter(DbType.Boolean, (uint)0)));
Assert.AreEqual("CAST((1=0) AS BOOLEAN)", HsqlConvert.ToSqlLiteral(new FakeDataParameter(DbType.Boolean, (long)0)));
Assert.AreEqual("CAST((1=0) AS BOOLEAN)", HsqlConvert.ToSqlLiteral(new FakeDataParameter(DbType.Boolean, (ulong)0)));
Assert.AreEqual("CAST((1=0) AS BOOLEAN)", HsqlConvert.ToSqlLiteral(new FakeDataParameter(DbType.Boolean, (float)0)));
Assert.AreEqual("CAST((1=0) AS BOOLEAN)", HsqlConvert.ToSqlLiteral(new FakeDataParameter(DbType.Boolean, (double)0)));
Assert.AreEqual("CAST((1=0) AS BOOLEAN)", HsqlConvert.ToSqlLiteral(new FakeDataParameter(DbType.Boolean, (decimal)0)));
Assert.AreEqual("CAST((1=1) AS BOOLEAN)", HsqlConvert.ToSqlLiteral(new FakeDataParameter(DbType.Boolean, true)));
Assert.AreEqual("CAST((1=1) AS BOOLEAN)", HsqlConvert.ToSqlLiteral(new FakeDataParameter(DbType.Boolean, "TrUe")));
Assert.AreEqual("CAST((1=1) AS BOOLEAN)", HsqlConvert.ToSqlLiteral(new FakeDataParameter(DbType.Boolean, (sbyte)1)));
Assert.AreEqual("CAST((1=1) AS BOOLEAN)", HsqlConvert.ToSqlLiteral(new FakeDataParameter(DbType.Boolean, (byte)1)));
Assert.AreEqual("CAST((1=1) AS BOOLEAN)", HsqlConvert.ToSqlLiteral(new FakeDataParameter(DbType.Boolean, (char)1)));
Assert.AreEqual("CAST((1=1) AS BOOLEAN)", HsqlConvert.ToSqlLiteral(new FakeDataParameter(DbType.Boolean, (char)'1')));
Assert.AreEqual("CAST((1=1) AS BOOLEAN)", HsqlConvert.ToSqlLiteral(new FakeDataParameter(DbType.Boolean, (short)1)));
Assert.AreEqual("CAST((1=1) AS BOOLEAN)", HsqlConvert.ToSqlLiteral(new FakeDataParameter(DbType.Boolean, (ushort)1)));
Assert.AreEqual("CAST((1=1) AS BOOLEAN)", HsqlConvert.ToSqlLiteral(new FakeDataParameter(DbType.Boolean, (int)1)));
Assert.AreEqual("CAST((1=1) AS BOOLEAN)", HsqlConvert.ToSqlLiteral(new FakeDataParameter(DbType.Boolean, (uint)1)));
Assert.AreEqual("CAST((1=1) AS BOOLEAN)", HsqlConvert.ToSqlLiteral(new FakeDataParameter(DbType.Boolean, (long)1)));
Assert.AreEqual("CAST((1=1) AS BOOLEAN)", HsqlConvert.ToSqlLiteral(new FakeDataParameter(DbType.Boolean, (ulong)1)));
Assert.AreEqual("CAST((1=1) AS BOOLEAN)", HsqlConvert.ToSqlLiteral(new FakeDataParameter(DbType.Boolean, (float)1)));
Assert.AreEqual("CAST((1=1) AS BOOLEAN)", HsqlConvert.ToSqlLiteral(new FakeDataParameter(DbType.Boolean, (double)1)));
Assert.AreEqual("CAST((1=1) AS BOOLEAN)", HsqlConvert.ToSqlLiteral(new FakeDataParameter(DbType.Boolean, (decimal)1)));
Assert.AreEqual("CAST((1=1) AS BOOLEAN)", HsqlConvert.ToSqlLiteral(new FakeDataParameter(DbType.Boolean, (sbyte)-1)));
Assert.AreEqual("CAST((1=1) AS BOOLEAN)", HsqlConvert.ToSqlLiteral(new FakeDataParameter(DbType.Boolean, (byte)1)));
Assert.AreEqual("CAST((1=1) AS BOOLEAN)", HsqlConvert.ToSqlLiteral(new FakeDataParameter(DbType.Boolean, (short)-1)));
Assert.AreEqual("CAST((1=1) AS BOOLEAN)", HsqlConvert.ToSqlLiteral(new FakeDataParameter(DbType.Boolean, (ushort)2)));
Assert.AreEqual("CAST((1=1) AS BOOLEAN)", HsqlConvert.ToSqlLiteral(new FakeDataParameter(DbType.Boolean, (int)-1)));
Assert.AreEqual("CAST((1=1) AS BOOLEAN)", HsqlConvert.ToSqlLiteral(new FakeDataParameter(DbType.Boolean, (uint)2)));
Assert.AreEqual("CAST((1=1) AS BOOLEAN)", HsqlConvert.ToSqlLiteral(new FakeDataParameter(DbType.Boolean, (long)-1)));
Assert.AreEqual("CAST((1=1) AS BOOLEAN)", HsqlConvert.ToSqlLiteral(new FakeDataParameter(DbType.Boolean, (ulong)2)));
Assert.AreEqual("CAST((1=1) AS BOOLEAN)", HsqlConvert.ToSqlLiteral(new FakeDataParameter(DbType.Boolean, (float)-1)));
Assert.AreEqual("CAST((1=1) AS BOOLEAN)", HsqlConvert.ToSqlLiteral(new FakeDataParameter(DbType.Boolean, (double)-1)));
Assert.AreEqual("CAST((1=1) AS BOOLEAN)", HsqlConvert.ToSqlLiteral(new FakeDataParameter(DbType.Boolean, (decimal) - 1)));
//--
Assert.AreEqual("CAST(1 AS SMALLINT)", HsqlConvert.ToSqlLiteral(new FakeDataParameter(DbType.Byte, (sbyte)1)));
Assert.AreEqual("CAST(1 AS SMALLINT)", HsqlConvert.ToSqlLiteral(new FakeDataParameter(DbType.Byte, (byte)1)));
Assert.AreEqual("CAST(1 AS SMALLINT)", HsqlConvert.ToSqlLiteral(new FakeDataParameter(DbType.Byte, (short)1)));
Assert.AreEqual("CAST(1 AS SMALLINT)", HsqlConvert.ToSqlLiteral(new FakeDataParameter(DbType.Byte, (ushort)1)));
Assert.AreEqual("CAST(1 AS SMALLINT)", HsqlConvert.ToSqlLiteral(new FakeDataParameter(DbType.Byte, (int)1)));
Assert.AreEqual("CAST(1 AS SMALLINT)", HsqlConvert.ToSqlLiteral(new FakeDataParameter(DbType.Byte, (uint)1)));
Assert.AreEqual("CAST(1 AS SMALLINT)", HsqlConvert.ToSqlLiteral(new FakeDataParameter(DbType.Byte, (long)1)));
Assert.AreEqual("CAST(1 AS SMALLINT)", HsqlConvert.ToSqlLiteral(new FakeDataParameter(DbType.Byte, (ulong)1)));
Assert.AreEqual("CAST(1 AS SMALLINT)", HsqlConvert.ToSqlLiteral(new FakeDataParameter(DbType.Byte, (float)1)));
Assert.AreEqual("CAST(1 AS SMALLINT)", HsqlConvert.ToSqlLiteral(new FakeDataParameter(DbType.Byte, (double)1)));
Assert.AreEqual("CAST(1 AS SMALLINT)", HsqlConvert.ToSqlLiteral(new FakeDataParameter(DbType.Byte, (decimal)1)));
}
/// <summary>
/// For the current row, gets an instance of the provider-specific
/// representation of the value of the field with the given column
/// ordinal.
/// </summary>
/// <remarks>
/// Because this method does not check if this reader
/// is open or if row data is available, it should be invoked
/// *only* when it is already known that this reader is open and
/// row data is available.
/// </remarks>
/// <param name="ordinal">The column ordinal.</param>
/// <returns>The provider-specific value representation.</returns>
internal object GetProviderSpecificValueInternal(int ordinal)
{
object value = m_currentRecord.data[ordinal];
if (value == null)
{
return(null);
}
int type = m_metaData.colTypes[ordinal];
switch (type)
{
case (int)HsqlProviderType.Array:
{
return(value);
}
case (int)HsqlProviderType.BigInt:
{
return(value);
}
case (int)HsqlProviderType.Binary:
{
return(((org.hsqldb.types.Binary)value).getClonedBytes());
}
case (int)HsqlProviderType.Blob:
{
return(value);
}
case (int)HsqlProviderType.Boolean:
{
return(value);
}
case (int)HsqlProviderType.Char:
{
return(value);
}
case (int)HsqlProviderType.Clob:
{
return(value);
}
case (int)HsqlProviderType.DataLink:
{
return(value);
}
case (int)HsqlProviderType.Date:
{
return((java.sql.Date)((java.sql.Date)value).clone());
}
case (int)HsqlProviderType.Decimal:
{
return(value);
}
case (int)HsqlProviderType.Distinct:
{
return(value);
}
case (int)HsqlProviderType.Double:
{
return(value);
}
case (int)HsqlProviderType.Float:
{
return(value);
}
case (int)HsqlProviderType.Integer:
{
return(value);
}
case (int)HsqlProviderType.JavaObject:
{
return(value);
}
case (int)HsqlProviderType.LongVarBinary:
{
return(((org.hsqldb.types.Binary)value).getClonedBytes());
}
case (int)HsqlProviderType.LongVarChar:
{
return(value);
}
case (int)HsqlProviderType.Null:
{
return(null);
}
case (int)HsqlProviderType.Numeric:
{
return(value);
}
case (int)HsqlProviderType.Object:
{
byte[] bytes = ((org.hsqldb.types.JavaObject)value).getBytes();
bool isJavaObject;
return(SqlObject.Deserialize(bytes, out isJavaObject));
}
case (int)HsqlProviderType.Real:
{
return(value);
}
case (int)HsqlProviderType.Ref:
{
return(value);
}
case (int)HsqlProviderType.SmallInt:
{
return(value);
}
case (int)HsqlProviderType.Struct:
{
return(value);
}
case (int)HsqlProviderType.Time:
{
return((java.sql.Time)((java.sql.Time)value).clone());
}
case (int)HsqlProviderType.TimeStamp:
{
return((java.sql.Timestamp)((java.sql.Timestamp)value).clone());
}
case (int)HsqlProviderType.TinyInt:
{
return(value);
}
case (int)HsqlProviderType.VarBinary:
{
byte[] bytes = ((org.hsqldb.types.Binary)value).getClonedBytes();
return(new org.hsqldb.types.Binary(bytes, false));
}
case (int)HsqlProviderType.VarChar:
{
return(value);
}
case (int)HsqlProviderType.Xml:
{
return(value);
}
default:
{
throw HsqlConvert.UnknownConversion(value, type);
}
}
}
internal void DeriveParametersInternal()
{
if (CommandType != CommandType.StoredProcedure)
{
throw new InvalidOperationException(string.Format(
"Operation not supported for CommandType: "
+ CommandType.ToString()));
}
Prepare();
HsqlStatement statement = m_statement;
ParameterMetaData pmd = statement.ParameterDescriptor.metaData;
string[] parameterNames = pmd.colNames;
int count = parameterNames.Length;
HsqlParameter[] parameters = new HsqlParameter[count];
for (int i = 0; i < count; i++)
{
string name = parameterNames[i];
ParameterMode mode = (ParameterMode)pmd.paramMode[i];
int type = pmd.colTypes[i];
int precision = pmd.colSizes[i];
int scale = pmd.colScales[i];
int nullability = pmd.colNullable[i];
HsqlProviderType providerType = (HsqlProviderType)type;
DbType dbType = HsqlConvert.ToDbType(providerType);
ParameterDirection?direction = HsqlConvert.ToParameterDirection(mode);
bool?isNullable = IsNullable(nullability);
bool isCharacter = IsCharacterType(type);
bool isNumber = (!isCharacter) && IsNumberType(type);
bool isTemporal = !(isCharacter || isNumber) && IsTemporalType(type);
int size = ToBufferSize(type, precision);
if (isCharacter)
{
precision = 0;
scale = 0;
}
else if (isNumber || isTemporal)
{
if (precision == 0)
{
precision = ToDefaultPrecision(type);
}
}
HsqlParameter parameter = new HsqlParameter();
parameter.DbType = dbType;
if (direction != null)
{
parameter.Direction = direction.Value;
}
if (isNullable != null)
{
parameter.IsNullable = isNullable.Value;
}
parameter.ParameterName = name;
parameter.Precision = (byte)Math.Min(byte.MaxValue, precision);
parameter.ProviderType = providerType;
parameter.Scale = (byte)Math.Min(byte.MaxValue, scale);
parameter.Size = size;
parameter.SourceVersion = DataRowVersion.Default;
parameters[i] = parameter;
}
HsqlParameterCollection pc = Parameters;
pc.Clear();
foreach (HsqlParameter parameter in parameters)
{
pc.Add(parameter);
}
}
/// <summary>Gets the value of the specified column as an XML value.</summary>
/// <returns>
/// A <see cref="SqlXml"/> value that contains
/// the XML stored within the corresponding field.
/// </returns>
/// <param name="ordinal">
/// The zero-based column ordinal.
/// </param>
/// <exception cref="T:System.ArgumentOutOfRangeException">
/// The index passed was outside the range of 0 to
/// FieldCount - 1
/// </exception>
/// <exception cref="T:System.InvalidCastException">
/// The retrieved data is not compatible with the
/// <see cref="SqlXml"/> type.
/// </exception>
public SqlXml GetSqlXml(int ordinal)
{
CheckClosed();
CheckAvailable();
object value = m_currentRecord.data[ordinal];
if (value == null)
{
return(SqlXml.Null);
}
if (value is org.hsqldb.types.JavaObject)
{
bool isJavaObject;
value = HsqlConvert.FromJava.UnWrap(value, out isJavaObject);
}
if (value is string)
{
string stringValue = value as string;
MemoryStream ms = new MemoryStream();
using (GZipStream gzs = new GZipStream(ms, CompressionMode.Compress))
using (TextWriter writer = new StreamWriter(gzs, Encoding.UTF8))
{
writer.Write(stringValue);
writer.Flush();
}
ms.Position = 0;
return(new SqlXml(new GZipStream(ms, CompressionMode.Decompress)));
}
else if (value is org.hsqldb.types.Binary)
{
byte[] bytes = ((org.hsqldb.types.Binary)value).getBytes();
return(new SqlXml(new MemoryStream(bytes)));
}
else if (value is byte[])
{
return(new SqlXml(new MemoryStream(value as byte[])));
}
else if (value is char[])
{
char[] chars = value as char[];
MemoryStream ms = new MemoryStream(1 + chars.Length / 2);
using (GZipStream gzs = new GZipStream(ms, CompressionMode.Compress))
using (TextWriter writer = new StreamWriter(gzs, Encoding.UTF8))
{
writer.Write(chars);
writer.Flush();
}
ms.Position = 0;
return(new SqlXml(new GZipStream(ms, CompressionMode.Decompress)));
}
throw new InvalidCastException(GetDataTypeName(ordinal),
HsqlConvert.WrongDataType(value));
}
public void GetNextAsLiteralValue()
{
// Create Constructor Parameters
Tokenizer testSubject = new Tokenizer();
List <NextAsLiteralValueTestParameters> testParameters =
new List <NextAsLiteralValueTestParameters>();
// Array Literal
testParameters.Add(new NextAsLiteralValueTestParameters(
"foo",
HsqlProviderType.Array,
null,
org.hsqldb.Trace.UNEXPECTED_TOKEN,
"SQL ARRAY literal tokens are not supposed to be supported"));
// BigInt Literal
testParameters.Add(new NextAsLiteralValueTestParameters(
"-1",
HsqlProviderType.BigInt,
null,
org.hsqldb.Trace.UNEXPECTED_TOKEN,
"Atomic retrieval of a negative BIGINT literal is not supposed to be supported."));
testParameters.Add(new NextAsLiteralValueTestParameters(
"0",
HsqlProviderType.BigInt,
new java.lang.Long(0),
null,
null));
testParameters.Add(new NextAsLiteralValueTestParameters(
"1",
HsqlProviderType.BigInt,
new java.lang.Long(1),
null,
null));
testParameters.Add(new NextAsLiteralValueTestParameters(
long.MaxValue.ToString(),
HsqlProviderType.BigInt,
new java.lang.Long(long.MaxValue),
null,
null));
testParameters.Add(new NextAsLiteralValueTestParameters(
long.MinValue.ToString(),
HsqlProviderType.BigInt,
null,
org.hsqldb.Trace.UNEXPECTED_TOKEN,
"Atomic retrieval of a negative BIGINT literal is not supposed to be supported."));
// Binary Literal
testParameters.Add(new NextAsLiteralValueTestParameters(
"/* a binary literal value */ 'AFD14E7B9F82' ",
HsqlProviderType.Binary,
new org.hsqldb.types.Binary(HsqlStringConverter.hexToByte("AFD14E7B9F82"), false),
null,
null));
foreach (NextAsLiteralValueTestParameters parameters in
testParameters)
{
Console.WriteLine(parameters);
testSubject.Reset(parameters.Chars);
try
{
object value = testSubject.GetNextAsLiteralValue(
parameters.ProviderType);
if (parameters.ErrorMessage != null)
{
Assert.Fail(parameters.ErrorMessage);
}
System.Type expectedValueType =
HsqlConvert.ToProviderSpecificDataType(
parameters.ProviderType);
Assert.IsAssignableFrom(expectedValueType,
parameters.Value);
Assert.IsAssignableFrom(expectedValueType,
value);
Assert.AreEqual(parameters.Value, value);
}
catch (AssertionException)
{
throw;
}
catch (HsqlDataSourceException hdse)
{
Assert.AreEqual(parameters.ErrorCode, -hdse.ErrorCode);
}
}
//testSubject.Reset("'AFD14E7B9F82'");
//object bytes = testSubject.GetNextAsLiteralValue(HsqlProviderType.Binary);
//Assert.IsInstanceOfType(typeof(org.hsqldb.types.Binary), bytes);
//testSubject.Reset("'CAFEBABE'");
//try
//{
// testSubject.GetNextAsLiteralValue(HsqlProviderType.Blob);
// Assert.Fail("SQL BLOB literal tokens are not supposed to be supported at this time");
//}
//catch (HsqlDataSourceException)
//{
//}
//testSubject.Reset("TRUE");
//testSubject.GetNextAsLiteralValue(HsqlProviderType.Boolean);
//testSubject.Reset("FALSE");
//testSubject.GetNextAsLiteralValue(HsqlProviderType.Boolean);
//testSubject.Reset("NULL");
//testSubject.GetNextAsLiteralValue(HsqlProviderType.Boolean);
////testSubject.GetNextAsLiteralValue(HsqlProviderType.Char);
//try
//{
// testSubject.GetNextAsLiteralValue(HsqlProviderType.Clob);
// Assert.Fail("SQL CLOB literal tokens are not supposed to be supported at this time");
//}
//catch (HsqlDataSourceException)
//{
//}
//try
//{
// testSubject.GetNextAsLiteralValue(HsqlProviderType.DataLink);
// Assert.Fail("SQL DATALINK literal tokens are not supposed to be supported at this time");
//}
//catch (HsqlDataSourceException)
//{
//}
////testSubject.GetNextAsLiteralValue(HsqlProviderType.Date);
////testSubject.GetNextAsLiteralValue(HsqlProviderType.Decimal);
//try
//{
// testSubject.GetNextAsLiteralValue(HsqlProviderType.Distinct);
// Assert.Fail("SQL DISTINCT literal tokens are not supposed to be supported");
//}
//catch (HsqlDataSourceException)
//{
//}
////testSubject.GetNextAsLiteralValue(HsqlProviderType.Double);
////testSubject.GetNextAsLiteralValue(HsqlProviderType.Float);
////testSubject.GetNextAsLiteralValue(HsqlProviderType.Integer);
//try
//{
// testSubject.GetNextAsLiteralValue(HsqlProviderType.JavaObject);
// Assert.Fail("SQL JAVA_OBJECT literal tokens are not supposed to be supported at this time");
//}
//catch (HsqlDataSourceException)
//{
//}
////testSubject.GetNextAsLiteralValue(HsqlProviderType.LongVarBinary);
////testSubject.GetNextAsLiteralValue(HsqlProviderType.LongVarChar);
////testSubject.GetNextAsLiteralValue(HsqlProviderType.Null);
////testSubject.GetNextAsLiteralValue(HsqlProviderType.Numeric);
////testSubject.GetNextAsLiteralValue(HsqlProviderType.Object);
////testSubject.GetNextAsLiteralValue(HsqlProviderType.Real);
//try
//{
// testSubject.GetNextAsLiteralValue(HsqlProviderType.Ref);
// Assert.Fail("SQL REF literal tokens are not supposed to be supported");
//}
//catch (HsqlDataSourceException)
//{
//}
////testSubject.GetNextAsLiteralValue(HsqlProviderType.SmallInt);
//try
//{
// testSubject.GetNextAsLiteralValue(HsqlProviderType.Struct);
// Assert.Fail("SQL STRUCT literal tokens are not supposed to be supported");
//}
//catch (HsqlDataSourceException)
//{
//}
////testSubject.GetNextAsLiteralValue(HsqlProviderType.Time);
////testSubject.GetNextAsLiteralValue(HsqlProviderType.TimeStamp);
////testSubject.GetNextAsLiteralValue(HsqlProviderType.TinyInt);
////testSubject.GetNextAsLiteralValue(HsqlProviderType.VarBinary);
////testSubject.GetNextAsLiteralValue(HsqlProviderType.VarChar);
//try
//{
// testSubject.GetNextAsLiteralValue(HsqlProviderType.Xml);
// Assert.Fail("SQL XML literal tokens are not supposed to be supported at this time");
//}
//catch (HsqlDataSourceException)
//{
//}
}
/// <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);
}
/// <summary>
/// Notifies the transaction participant that the enlistment has completed successfully.
/// </summary>
/// <exception cref="TransactionException">
/// When an attempt to enlist or serialize the transaction fails.
/// </exception>
void IPromotableSinglePhaseNotification.Initialize()
{
m_dbTransaction = m_dbConnection.BeginTransaction(
HsqlConvert.ToIsolationLevel(m_systemTransaction.IsolationLevel));
}
public void LiteralValue()
{
List <LiteralValueTestParameters> testParameters = new List <LiteralValueTestParameters>();
testParameters.Add(new LiteralValueTestParameters(
"1234",
SqlTokenType.BigIntLiteral,
HsqlProviderType.BigInt,
HsqlValuePool.getLong(1234L),
null,
null));
testParameters.Add(new LiteralValueTestParameters(
"TRUE",
SqlTokenType.BooleanLiteral,
HsqlProviderType.Boolean,
JavaBoolean.TRUE,
null,
null));
testParameters.Add(new LiteralValueTestParameters(
"2009-2-8",
SqlTokenType.DateLiteral,
HsqlProviderType.Date,
HsqlDateTime.dateValue("2009-2-8"),
null,
null));
testParameters.Add(new LiteralValueTestParameters(
"12345678987654321.12345678987654321",
SqlTokenType.DecimalLiteral,
HsqlProviderType.Decimal,
new JavaDecimal("12345678987654321.12345678987654321"),
null,
null));
testParameters.Add(new LiteralValueTestParameters(
"123.456",
SqlTokenType.FloatLiteral,
HsqlProviderType.Double,
new JavaDouble(123.456D),
null,
null));
testParameters.Add(new LiteralValueTestParameters(
"FOO",
SqlTokenType.Null,
HsqlProviderType.Null,
null,
null,
null));
testParameters.Add(new LiteralValueTestParameters(
"1234567898765432123456712345678987654321234567.1234567898765432123456712345678987654321234567",
SqlTokenType.NumberLiteral,
HsqlProviderType.Numeric,
new JavaDecimal("1234567898765432123456712345678987654321234567.1234567898765432123456712345678987654321234567"),
null,
null));
testParameters.Add(new LiteralValueTestParameters(
"He said 'high five!'",
SqlTokenType.StringLiteral,
HsqlProviderType.VarChar,
"He said 'high five!'",
null,
null));
testParameters.Add(new LiteralValueTestParameters(
"12:01:01",
SqlTokenType.TimeLiteral,
HsqlProviderType.Time,
HsqlDateTime.timeValue("12:01:01"),
null,
null));
testParameters.Add(new LiteralValueTestParameters(
"2009-02-09 12:01:01.123456",
SqlTokenType.TimestampLiteral,
HsqlProviderType.TimeStamp,
HsqlDateTime.timestampValue("2009-02-09 12:01:01.123456"),
null,
null));
foreach (LiteralValueTestParameters item in testParameters)
{
Console.WriteLine(item);
try
{
Token token = new Token(item.Chars, item.TokenType);
object value = token.LiteralValue;
if (item.ErrorMessage != null)
{
Assert.Fail(item.ErrorMessage);
}
System.Type expectedType = HsqlConvert.ToProviderSpecificDataType(item.ProviderType);
if (expectedType != null && !(typeof(void).Equals(expectedType)))
{
Assert.IsInstanceOfType(expectedType, value);
}
Assert.AreEqual(item.Value, value);
}
catch (AssertionException)
{
throw;
}
catch (HsqlDataSourceException hdse)
{
Assert.AreEqual(item.ErrorCode, -hdse.ErrorCode);
}
}
}
/// <summary>
/// Gets the <c>System.Data.SqlTypes</c> representation
/// of the value of the field with the given column ordinal
/// in the current row of the result set.
/// </summary>
/// <remarks>
/// Because this method does not check if this reader
/// is open or if row data is available, it should be invoked
/// *only* when it is already known that this reader is open and
/// row data is available.
/// </remarks>
/// <param name="ordinal">The column ordinal.</param>
/// <returns>The <c>System.Data.SqlTypes</c> representation</returns>
internal object GetSqlValueInternal(int ordinal)
{
object value = m_currentRecord.data[ordinal];
bool isNull = (value == null);
int type = m_metaData.colTypes[ordinal];
switch (type)
{
case org.hsqldb.Types.ARRAY:
{
throw HsqlConvert.InvalidConversion(type);
}
case org.hsqldb.Types.BIGINT:
{
return((isNull)
? SqlInt64.Null
: new SqlInt64(((java.lang.Long)value).longValue()));
}
case org.hsqldb.Types.BINARY:
{
return((isNull)
? SqlBinary.Null
: new SqlBinary(((org.hsqldb.types.Binary)value).getBytes()));
}
case org.hsqldb.Types.BLOB:
{
throw HsqlConvert.InvalidConversion(type);
}
case org.hsqldb.Types.BOOLEAN:
{
return((isNull)
? SqlBoolean.Null
: ((java.lang.Boolean)value).booleanValue()
? SqlBoolean.True
: SqlBoolean.False);
}
case org.hsqldb.Types.CHAR:
{
return((isNull)
? SqlString.Null
: new SqlString((string)value));
}
case org.hsqldb.Types.CLOB:
{
throw HsqlConvert.InvalidConversion(type);
}
case org.hsqldb.Types.DATALINK:
{
throw HsqlConvert.InvalidConversion(type);
}
case org.hsqldb.Types.DATE:
{
return((isNull)
? SqlDateTime.Null
: new SqlDateTime(
HsqlConvert.FromJava.ToDate(((java.sql.Date)value).getTime())));
}
case org.hsqldb.Types.DECIMAL:
{
return((isNull)
? SqlDecimal.Null
: new SqlDecimal(HsqlConvert.FromJava.ToDecimal((java.math.BigDecimal)value)));
}
case org.hsqldb.Types.DISTINCT:
{
throw HsqlConvert.InvalidConversion(type);
}
case org.hsqldb.Types.DOUBLE:
{
return((isNull)
? SqlDouble.Null
: new SqlDouble(((java.lang.Double)value).doubleValue()));
}
case org.hsqldb.Types.FLOAT:
{
return((isNull)
? SqlDouble.Null
: new SqlDouble(((java.lang.Double)value).doubleValue()));
}
case org.hsqldb.Types.INTEGER:
{
return((isNull)
? SqlInt32.Null
: new SqlInt32(((java.lang.Integer)value).intValue()));
}
case org.hsqldb.Types.JAVA_OBJECT:
{
throw HsqlConvert.InvalidConversion(type);
}
case org.hsqldb.Types.LONGVARBINARY:
{
return((isNull)
? SqlBinary.Null
: new SqlBinary(((org.hsqldb.types.Binary)value).getBytes()));
}
case org.hsqldb.Types.LONGVARCHAR:
{
return((isNull)
? SqlString.Null
: new SqlString((string)value));
}
case org.hsqldb.Types.NULL:
{
throw HsqlConvert.InvalidConversion(type);
}
case org.hsqldb.Types.NUMERIC:
{
return((isNull)
? SqlDecimal.Null
: new SqlDecimal(HsqlConvert.FromJava.ToDecimal((java.math.BigDecimal)value)));
}
case org.hsqldb.Types.OTHER:
{
throw HsqlConvert.InvalidConversion(type);
}
case org.hsqldb.Types.REAL:
{
return((isNull)
? SqlSingle.Null
: new SqlSingle(((java.lang.Double)value).floatValue()));
}
case org.hsqldb.Types.REF:
{
throw HsqlConvert.InvalidConversion(type);
}
case org.hsqldb.Types.SMALLINT:
{
return((isNull)
? SqlInt16.Null
: new SqlInt16(((java.lang.Integer)value).shortValue()));
}
case org.hsqldb.Types.STRUCT:
{
throw HsqlConvert.InvalidConversion(type);
}
case org.hsqldb.Types.TIME:
{
return((isNull)
? SqlDateTime.Null
: new SqlDateTime(
HsqlConvert.FromJava.ToTime(((java.sql.Time)value).getTime())));
}
case org.hsqldb.Types.TIMESTAMP:
{
return((isNull)
? SqlDateTime.Null
: new SqlDateTime(
HsqlConvert.FromJava.ToTimestamp(((java.sql.Timestamp)value).getTime())));
}
case org.hsqldb.Types.TINYINT:
{
return((isNull)
? SqlInt16.Null
: new SqlInt16(((java.lang.Integer)value).shortValue()));
}
case org.hsqldb.Types.VARBINARY:
{
return((isNull)
? SqlBinary.Null
: new SqlBinary(((org.hsqldb.types.Binary)value).getBytes()));
}
case org.hsqldb.Types.VARCHAR:
{
return((isNull)
? SqlString.Null
: new SqlString((string)value));
}
case org.hsqldb.Types.VARCHAR_IGNORECASE:
{
return((isNull)
? SqlString.Null
: new SqlString((string)value));
}
case org.hsqldb.Types.XML:
{
throw HsqlConvert.InvalidConversion(type);
}
default:
{
throw HsqlConvert.InvalidConversion(type);
}
}
}
/// <summary>
/// Adds a new <c>DataRow</c> to the given <c>DataTable</c>.
/// </summary>
/// <remarks>
/// It is assumed the given table's column collection is
/// compatibly pre-initialized.
/// </remarks>
/// <param name="dataTable">
/// The <c>DataTable</c> to which to add the row.
/// </param>
/// <param name="columnName">
/// Specifies the name of the column in the schema table.
/// </param>
/// <param name="columnOrdinal">
/// Specifies the ordinal of the column.
/// </param>
/// <param name="columnSize">
/// Specifies the size of the column.
/// </param>
/// <param name="numericPrecision">
/// Specifies the precision of the column data, if the data is numeric.
/// </param>
/// <param name="numericScale">
/// Specifies the scale of the column data, if the data is numeric.
/// </param>
/// <param name="isUnique">
/// Specifies whether a unique constraint applies to this column.
/// </param>
/// <param name="isKey">
/// Specifies whether this column is a key for the table.
/// </param>
/// <param name="baseServerName">
/// Specifies the server name of the column.
/// </param>
/// <param name="baseCatalogName">
/// The name of the catalog associated with the results of the latest
/// query.
/// </param>
/// <param name="baseColumnName">
/// Specifies the name of the column in the schema table.
/// </param>
/// <param name="baseSchemaName">
/// Specifies the name of the schema in the schema table.
/// </param>
/// <param name="baseTableName">
/// Specifies the name of the table in the schema table.
/// </param>
/// <param name="dataType">
/// Specifies the type of data in the column.
/// </param>
/// <param name="allowDBNull">
/// Specifies whether value DBNull is allowed.
/// </param>
/// <param name="providerType">
/// Specifies the provider-specific data type of the column.
/// </param>
/// <param name="isAliased">
/// Specifies whether this column is aliased.
/// </param>
/// <param name="isExpression">
/// Specifies whether this column is an expression.
/// </param>
/// <param name="isIdentity">
/// Specifies whether this column is the identity for the schema table.
/// </param>
/// <param name="isAutoIncrement">
/// Specifies whether the column values in the column are automatically
/// incremented.
/// </param>
/// <param name="isRowVersion">
/// Specifies whether this column contains row version information.
/// </param>
/// <param name="isHidden">
/// Specifies whether this column is hidden.
/// </param>
/// <param name="isLong">
/// Specifies whether this column contains long data.
/// </param>
/// <param name="isReadOnly">
/// Specifies whether this column is read-only.
/// </param>
public static void AddRow(
DataTable dataTable,
string columnName,
int columnOrdinal,
int columnSize,
int numericPrecision,
int numericScale,
bool isUnique,
bool isKey,
string baseServerName,
string baseCatalogName,
string baseColumnName,
string baseSchemaName,
string baseTableName,
Type dataType,
bool allowDBNull,
int providerType,
bool isAliased,
bool isExpression,
bool isIdentity,
bool isAutoIncrement,
bool isRowVersion,
bool isHidden,
bool isLong,
bool isReadOnly)
{
DataRow row = dataTable.NewRow();
row[STC.ColumnName] = columnName;
row[STC.ColumnOrdinal] = columnOrdinal;
row[STC.ColumnSize] = columnSize;
row[STC.NumericPrecision] = numericPrecision;
row[STC.NumericScale] = numericScale;
row[STC.IsUnique] = isUnique;
row[STC.IsKey] = isKey;
row[STOC.BaseServerName] = baseServerName;
row[STOC.BaseCatalogName] = baseCatalogName;
row[STC.BaseColumnName] = baseColumnName;
row[STC.BaseSchemaName] = baseSchemaName;
row[STC.BaseTableName] = baseTableName;
row[STC.DataType] = dataType;
row[STC.AllowDBNull] = allowDBNull;
row[STC.ProviderType] = providerType;
row[STC.IsAliased] = isAliased;
row[STC.IsExpression] = isExpression;
row["IsIdentity"] = isIdentity;
row[STOC.IsAutoIncrement] = isAutoIncrement;
row[STOC.IsRowVersion] = isRowVersion;
row[STOC.IsHidden] = isHidden;
row[STC.IsLong] = isLong;
row[STOC.IsReadOnly] = isReadOnly;
row[STOC.ProviderSpecificDataType] = HsqlConvert.ToProviderSpecificDataType(providerType);
row["DataTypeName"] = HsqlConvert.ToSqlDataTypeName(providerType);
//row["XmlSchemaCollectionDatabase"] = null;
//row["XmlSchemaCollectionOwningSchema"] = null;
//row["XmlSchemaCollectionName"] = null;
//row["UdtAssemblyQualifiedName"] = null;
row[STC.NonVersionedProviderType] = providerType;
dataTable.Rows.Add(row);
}
///// <summary>
///// Sets the parameter properties.
///// </summary>
///// <param name="parameterName">Name of the parameter.</param>
///// <param name="sourceColumn">The source column.</param>
///// <param name="sourceVersion">The source version.</param>
///// <param name="precision">The precision.</param>
///// <param name="scale">The scale.</param>
///// <param name="size">The size.</param>
///// <param name="forceSize">if set to <c>true</c>, force size.</param>
///// <param name="offset">The offset.</param>
///// <param name="parameterDirection">The parameter direction.</param>
///// <param name="value">The value.</param>
///// <param name="dbType">The data type</param>
///// <param name="suppress">if set to <c>true</c>, suppress.</param>
///// <param name="inferType">if set to <c>true</c>, infer type.</param>
//internal void SetProperties(
// string parameterName,
// string sourceColumn,
// DataRowVersion sourceVersion,
// byte precision,
// byte scale,
// int size,
// bool forceSize,
// int offset,
// ParameterDirection parameterDirection,
// object value,
// DbType dbType,
// bool suppress,
// bool inferType)
//{
// m_name = parameterName;
// m_sourceColumn = sourceColumn;
// SourceVersion = sourceVersion;
// m_precision = precision;
// m_scale = scale;
// m_size = size;
// m_forceSize = forceSize;
// m_offset = offset;
// m_direction = parameterDirection;
// ICloneable cloneable = value as ICloneable;
// m_value = (cloneable == null) ? value : cloneable.Clone();
// m_dbType = dbType;
// m_suppressed = suppress;
// m_inferType = inferType;
// m_assigned = true;
//}
#endregion
#region ToSqlLiteral()
/// <summary>
/// Gets the value as an SQL literal string.
/// </summary>
///
/// <returns>
/// The value as an SQL literal string.
/// </returns>
public string ToSqlLiteral()
{
return(HsqlConvert.ToSqlLiteral(this));
}
