public static SqlDataRecord SetInt16(this SqlDataRecord r, int pos, short?v)
{
if (!v.HasValue)
{
r.SetDBNull(pos);
}
else
{
r.SetInt16(pos, v.Value);
}
return(r);
}
public override void Set(SqlDataRecord record, int ordinal, string value)
{
EnsureArg.IsNotNull(record, nameof(record));
if (value != null)
{
record.SetString(ordinal, value);
}
else
{
record.SetDBNull(ordinal);
}
}
public override void Set(SqlDataRecord record, int ordinal, byte[] value)
{
EnsureArg.IsNotNull(record, nameof(record));
if (value != null)
{
record.SetBytes(ordinal, fieldOffset: 0, value, bufferOffset: 0, value.Length);
}
else
{
record.SetDBNull(ordinal);
}
}
public override void Set(SqlDataRecord record, int ordinal, byte?value)
{
EnsureArg.IsNotNull(record, nameof(record));
if (value.HasValue)
{
record.SetByte(ordinal, value.Value);
}
else
{
record.SetDBNull(ordinal);
}
}
public override void Set(SqlDataRecord record, int ordinal, DateTime?value)
{
EnsureArg.IsNotNull(record, nameof(record));
if (value == null)
{
record.SetDBNull(ordinal);
}
else
{
record.SetDateTime(ordinal, value.Value);
}
}
private static IEnumerable <SqlDataRecord> BindOrderRows(IEnumerable <OrderEntity> ordersToUpdate)
{
foreach (var order in ordersToUpdate)
{
SqlDataRecord record = new SqlDataRecord(typ_OrderTable);
record.SetInt64(0, order.OrderId);
record.SetInt64(1, order.UserId);
record.SetDateTime(2, order.OrderDate);
record.SetDecimal(3, order.SubTotal);
if (order.Tax.HasValue)
{
record.SetDecimal(4, order.Tax.Value);
}
else
{
record.SetDBNull(4);
}
if (order.OtherCharges.HasValue)
{
record.SetDecimal(5, order.OtherCharges.Value);
}
else
{
record.SetDBNull(5);
}
if (!string.IsNullOrWhiteSpace(order.Notes))
{
record.SetString(6, order.Notes);
}
else
{
record.SetDBNull(6);
}
record.SetInt32(7, (int)order.Status);
yield return(record);
}
}
public static void FileStringSplitToTable(
SqlString fileName, SqlString delimiter)
{
string[] delimiters = new string[] { delimiter.Value };
using (System.IO.StreamReader sr = new System.IO.StreamReader(new System.IO.FileStream(
fileName.Value, System.IO.FileMode.Open, System.IO.FileAccess.Read, System.IO.FileShare.Read)))
{
string str;
SqlMetaData[] sqlMetadatas = null;
bool fFirst = true;
while ((str = sr.ReadLine()) != null)
{
string[] tokens = str.Split(delimiters, StringSplitOptions.None);
if (sqlMetadatas == null)
{
sqlMetadatas = new SqlMetaData[tokens.Length];
for (int iToken = 0; iToken < tokens.Length; iToken++)
{
sqlMetadatas[iToken] = new SqlMetaData("Field_" + iToken, System.Data.SqlDbType.NVarChar, -1);
}
}
#region Output fields
SqlDataRecord record = new SqlDataRecord(sqlMetadatas);
int i;
for (i = 0; i < tokens.Length; i++)
{
record.SetString(i, tokens[i]);
}
for (; i < sqlMetadatas.Length; i++) // add NULLs if need be.
{
record.SetDBNull(i);
}
if (fFirst)
{
SqlContext.Pipe.SendResultsStart(record);
fFirst = false;
}
SqlContext.Pipe.SendResultsRow(record);
#endregion
}
SqlContext.Pipe.SendResultsEnd();
}
}
private static SqlDataRecord CreateIntegerRecord(int?value)
{
var record = new SqlDataRecord(new SqlMetaData("Value", SqlDbType.Int));
if (value.HasValue)
{
record.SetInt32(0, value.Value);
}
else
{
record.SetDBNull(0);
}
return(record);
}
private static SqlDataRecord CreateLongRecord(long?value)
{
var record = new SqlDataRecord(new SqlMetaData("Value", SqlDbType.BigInt));
if (value.HasValue)
{
record.SetInt64(0, value.Value);
}
else
{
record.SetDBNull(0);
}
return(record);
}
private static SqlDataRecord CreateFractalRecord(float?value)
{
var record = new SqlDataRecord(new SqlMetaData("Value", SqlDbType.Real));
if (value.HasValue)
{
record.SetFloat(0, value.Value);
}
else
{
record.SetDBNull(0);
}
return(record);
}
private static SqlDataRecord CreateBooleanRecord(bool?value)
{
var record = new SqlDataRecord(new SqlMetaData("Value", SqlDbType.Bit));
if (value.HasValue)
{
record.SetBoolean(0, value.Value);
}
else
{
record.SetDBNull(0);
}
return(record);
}
private static SqlDataRecord CreateDateTimeRecord(DateTime?value)
{
var record = new SqlDataRecord(new SqlMetaData("Value", SqlDbType.DateTime2));
if (value.HasValue)
{
record.SetDateTime(0, value.Value);
}
else
{
record.SetDBNull(0);
}
return(record);
}
private static SqlDataRecord CreateGuidRecord(Guid?value)
{
var record = new SqlDataRecord(new SqlMetaData("Value", SqlDbType.UniqueIdentifier));
if (value.HasValue)
{
record.SetGuid(0, value.Value);
}
else
{
record.SetDBNull(0);
}
return(record);
}
IEnumerator <SqlDataRecord> IEnumerable <SqlDataRecord> .GetEnumerator()
{
var sdr = new SqlDataRecord(
new SqlMetaData("HtmlUploadId", SqlDbType.BigInt),
new SqlMetaData("ImageTenantId", SqlDbType.BigInt),
new SqlMetaData("ThumbnailImageUploadId", SqlDbType.BigInt),
new SqlMetaData("PreviewImageUploadId", SqlDbType.BigInt),
new SqlMetaData("ImageUploadId", SqlDbType.BigInt),
new SqlMetaData("UploadTenantId", SqlDbType.BigInt),
new SqlMetaData("UploadId", SqlDbType.BigInt)
);
foreach (HtmlBlobSet blobSet in this)
{
sdr.SetInt64(0, blobSet.BlobSetId);
sdr.SetDBNull(1);
sdr.SetInt64(2, blobSet.ThumbnailImageBlobId);
sdr.SetInt64(3, blobSet.PreviewImageBlobId);
sdr.SetInt64(4, blobSet.ImageBlobId);
sdr.SetDBNull(5);
sdr.SetDBNull(6);
yield return(sdr);
}
}
private static void SetBitToDataRecord(ref SqlDataRecord record, int index, bool?value)
{
try
{
if (value.HasValue)
{
record.SetSqlBoolean(index, value.Value);
}
else
{
record.SetDBNull(index);
}
}
catch (Exception ex)
{
Logger.Error(ex);
}
}
internal static SqlDataRecord MapToTvp(this LogMessage message)
{
var record = new SqlDataRecord(Constants.MessageMetadata);
record.SetGuid(0, message.OwnerLog.LogUUID);
record.SetString(1, message.LogMessageText.LogMessageHash);
record.SetInt32(2, message.Depth);
if (message.LogStackTrace == null)
{
record.SetDBNull(3);
}
else
{
record.SetString(3, message.LogStackTrace.StackHash);
}
return(record);
}
private static SqlDataRecord CreateStringRecord(string value)
{
var record = new SqlDataRecord(new SqlMetaData("Value", SqlDbType.NVarChar, MaxStringLength));
if (!string.IsNullOrWhiteSpace(value))
{
if (value.Length > MaxStringLength)
{
throw new SisoDbException(ExceptionMessages.SqlServerTableParams_ToLongString.Inject(MaxStringLength, value));
}
record.SetString(0, value);
}
else
{
record.SetDBNull(0);
}
return(record);
}
IEnumerator <SqlDataRecord> IEnumerable <SqlDataRecord> .GetEnumerator()
{
var sdr = new SqlDataRecord(
new SqlMetaData("TagId", SqlDbType.BigInt),
new SqlMetaData("Name", SqlDbType.NVarChar, 50)
);
foreach (Tag tag in this)
{
if (tag.TagId == 0)
{
sdr.SetDBNull(0);
}
else
{
sdr.SetInt64(0, tag.TagId);
}
sdr.SetString(1, tag.Name);
yield return(sdr);
}
}
public void SendRow(SqlDataRecord dataRecord, object[] items)
{
for (int i = 0; i < items.Length; i++)
{
string value = items[i].ToStringSafe();
if (string.IsNullOrEmpty(value))
{
dataRecord.SetDBNull(i);
}
else
{
dataRecord.SetString(i, value);
}
}
if (SqlContext.IsAvailable && SqlContext.Pipe != null)
{
// Send the row back to the client.
SqlContext.Pipe.SendResultsRow(dataRecord);
}
}
IEnumerator <SqlDataRecord> IEnumerable <SqlDataRecord> .GetEnumerator()
{
var record = new SqlDataRecord(
new SqlMetaData("Id", SqlDbType.Int),
new SqlMetaData("Nodes", SqlDbType.NVarChar, -1)
);
foreach (var value in this)
{
record.SetInt32(0, value.Id);
if (!string.IsNullOrWhiteSpace(value.Nodes))
{
record.SetString(1, value.Nodes);
}
else
{
record.SetDBNull(1);
}
yield return(record);
}
}
/// <summary>
/// Retrieves master page zone element type records.
/// </summary>
/// <returns>Enumerable SQL data records.</returns>
IEnumerator <SqlDataRecord> IEnumerable <SqlDataRecord> .GetEnumerator()
{
var sdr = new SqlDataRecord(
new SqlMetaData("MasterPageZoneId", SqlDbType.BigInt),
new SqlMetaData("MasterPageZoneSortOrder", SqlDbType.Int),
new SqlMetaData("ElementTypeId", SqlDbType.UniqueIdentifier)
);
foreach (MasterPageZoneElementType masterPageZoneElementType in this)
{
if (masterPageZoneElementType.MasterPageZoneId != 0)
{
sdr.SetInt64(0, masterPageZoneElementType.MasterPageZoneId);
}
else
{
sdr.SetDBNull(0);
}
sdr.SetInt32(1, masterPageZoneElementType.MasterPageZoneSortOrder);
sdr.SetGuid(2, masterPageZoneElementType.ElementTypeId);
yield return(sdr);
}
}
/// <summary>
/// Sets the database null.
/// </summary>
/// <param name="record">The record.</param>
/// <param name="fieldName">Name of the field.</param>
public static void SetDBNull(this SqlDataRecord record, string fieldName)
{
int ordinal = GetOrdinal(record, fieldName);
record.SetDBNull(ordinal);
}
IEnumerator <SqlDataRecord> IEnumerable <SqlDataRecord> .GetEnumerator()
{
SqlDataRecord ret = new SqlDataRecord(
new SqlMetaData("EmailVerificationID", SqlDbType.Int),
new SqlMetaData("VerficationCode", SqlDbType.VarChar, -1),
new SqlMetaData("ExpiryDate", SqlDbType.DateTime),
new SqlMetaData("MemberId", SqlDbType.Int),
new SqlMetaData("Isused", SqlDbType.Bit),
new SqlMetaData("ProfileType", SqlDbType.VarChar, -1)
);
foreach (Email_Verification data in this)
{
if (CheckNullOrEmpty(data.EmailVerificationID))
{
ret.SetDBNull(0);
}
else
{
ret.SetInt32(0, data.EmailVerificationID);
}
if (CheckNullOrEmpty(data.VerficationCode))
{
ret.SetDBNull(1);
}
else
{
ret.SetString(1, data.VerficationCode);
}
if (CheckNullOrEmpty(data.ExpiryDate))
{
ret.SetDBNull(2);
}
else
{
ret.SetDateTime(2, data.ExpiryDate);
}
if (CheckNullOrEmpty(data.MemberId))
{
ret.SetDBNull(3);
}
else
{
ret.SetInt32(3, data.MemberId);
}
if (CheckNullOrEmpty(data.Isused))
{
ret.SetDBNull(4);
}
else
{
ret.SetBoolean(4, data.Isused);
}
if (CheckNullOrEmpty(data.ProfileType))
{
ret.SetDBNull(5);
}
else
{
ret.SetString(5, data.ProfileType);
}
yield return(ret);
}
}
public void SqlRecordFillTest()
{
SqlMetaData[] metaData = new SqlMetaData[]
{
new SqlMetaData("col1", SqlDbType.Bit),
new SqlMetaData("col2", SqlDbType.TinyInt),
new SqlMetaData("col3", SqlDbType.VarBinary, 1000),
new SqlMetaData("col4", SqlDbType.NVarChar, 1000),
new SqlMetaData("col5", SqlDbType.DateTime),
new SqlMetaData("col6", SqlDbType.Float),
new SqlMetaData("col7", SqlDbType.UniqueIdentifier),
new SqlMetaData("col8", SqlDbType.SmallInt),
new SqlMetaData("col9", SqlDbType.Int),
new SqlMetaData("col10", SqlDbType.BigInt),
new SqlMetaData("col11", SqlDbType.Real),
new SqlMetaData("col12", SqlDbType.Decimal),
new SqlMetaData("col13", SqlDbType.Money),
new SqlMetaData("col14", SqlDbType.Variant)
};
SqlDataRecord record = new SqlDataRecord(metaData);
for (int i = 0; i < record.FieldCount; i++)
{
Assert.Equal($"col{i + 1}", record.GetName(i));
}
record.SetBoolean(0, true);
Assert.Equal(true, record.GetBoolean(0));
record.SetByte(1, 1);
Assert.Equal(1, record.GetByte(1));
byte[] bb1 = new byte[] { 1, 2, 3, 4, 5, 6, 7, 8, 9 };
byte[] bb2 = new byte[5];
record.SetSqlBinary(2, new SqlBinary(new byte[0]));
record.SetBytes(2, 0, bb1, 0, 3);
record.SetBytes(2, 2, bb1, 6, 3);
// Verify the length of the byte array
Assert.Equal(5, record.GetBytes(2, 0, bb2, 0, 5));
Assert.Equal(5, record.GetBytes(2, 0, null, 0, 0));
byte[] expected = new byte[] { 1, 2, 7, 8, 9 };
Assert.Equal <byte>(expected, bb2);
char[] cb1 = new char[] { 'a', 'b', 'c', 'd', 'e', 'f', 'g' };
char[] cb2 = new char[5];
record.SetChars(3, 0, cb1, 0, 3);
record.SetChars(3, 2, cb1, 4, 3);
char[] expectedValue = new char[] { 'a', 'b', 'e', 'f', 'g' };
Assert.Equal(expectedValue.Length, record.GetChars(3, 0, cb2, 0, 5));
Assert.Equal <char>(expectedValue, new string(cb2, 0, (int)record.GetChars(3, 0, null, 0, 0)));
record.SetString(3, "");
string xyz = "xyz";
record.SetString(3, "xyz");
Assert.Equal(xyz, record.GetString(3));
Assert.Equal(xyz.Length, record.GetChars(3, 0, cb2, 0, 5));
Assert.Equal(xyz, new string(cb2, 0, (int)record.GetChars(3, 0, null, 0, 0)));
record.SetChars(3, 2, cb1, 4, 3);
Assert.Equal(5, record.GetChars(3, 0, cb2, 0, 5));
string interleavedResult = "xyefg";
Assert.Equal(interleavedResult, new string(cb2, 0, (int)record.GetChars(3, 0, null, 0, 0)));
Assert.Equal(interleavedResult, record.GetString(3));
record.SetSqlDateTime(4, SqlDateTime.MaxValue);
Assert.Equal(SqlDateTime.MaxValue, record.GetSqlDateTime(4));
record.SetSqlDouble(5, SqlDouble.MaxValue);
Assert.Equal(SqlDouble.MaxValue, record.GetSqlDouble(5));
SqlGuid guid = new SqlGuid("F9168C5E-CEB2-4faa-B6BF-329BF39FA1E4");
record.SetSqlGuid(6, guid);
Assert.Equal(guid, record.GetSqlGuid(6));
record.SetSqlInt16(7, SqlInt16.MaxValue);
Assert.Equal(SqlInt16.MaxValue, record.GetSqlInt16(7));
record.SetSqlInt32(8, SqlInt32.MaxValue);
Assert.Equal(SqlInt32.MaxValue, record.GetSqlInt32(8));
record.SetSqlInt64(9, SqlInt64.MaxValue);
Assert.Equal(SqlInt64.MaxValue, record.GetSqlInt64(9));
record.SetSqlSingle(10, SqlSingle.MinValue);
Assert.Equal(SqlSingle.MinValue, record.GetSqlSingle(10));
record.SetSqlDecimal(11, SqlDecimal.Null);
record.SetSqlDecimal(11, SqlDecimal.MaxValue);
Assert.Equal(SqlDecimal.MaxValue, record.GetSqlDecimal(11));
record.SetSqlMoney(12, SqlMoney.MaxValue);
Assert.Equal(SqlMoney.MaxValue, record.GetSqlMoney(12));
// Try adding different values to SqlVariant type
for (int i = 0; i < record.FieldCount - 1; ++i)
{
object valueToSet = record.GetSqlValue(i);
record.SetValue(record.FieldCount - 1, valueToSet);
object o = record.GetSqlValue(record.FieldCount - 1);
if (o is SqlBinary)
{
Assert.Equal <byte>(((SqlBinary)valueToSet).Value, ((SqlBinary)o).Value);
}
else
{
Assert.Equal(valueToSet, o);
}
record.SetDBNull(record.FieldCount - 1);
Assert.Equal(DBNull.Value, record.GetSqlValue(record.FieldCount - 1));
record.SetDBNull(i);
Assert.Equal(DBNull.Value, record.GetValue(i));
}
}
IEnumerator <SqlDataRecord> IEnumerable <SqlDataRecord> .GetEnumerator()
{
SqlDataRecord ret = new SqlDataRecord(
new SqlMetaData("Hall_ID", SqlDbType.Int),
new SqlMetaData("Hall_Name", SqlDbType.VarChar, -1),
new SqlMetaData("Username", SqlDbType.VarChar, -1),
new SqlMetaData("Password", SqlDbType.VarChar, -1),
new SqlMetaData("Email", SqlDbType.VarChar, -1),
new SqlMetaData("Country", SqlDbType.VarChar, -1),
new SqlMetaData("City", SqlDbType.VarChar, -1),
new SqlMetaData("Capacity", SqlDbType.VarChar, -1),
new SqlMetaData("Amount", SqlDbType.VarChar, -1),
new SqlMetaData("Type", SqlDbType.VarChar, -1),
new SqlMetaData("Office_Contact", SqlDbType.VarChar, -1),
new SqlMetaData("Office_Hours_From", SqlDbType.VarChar, -1),
new SqlMetaData("Office_Hours_To", SqlDbType.VarChar, -1),
new SqlMetaData("Website_Url", SqlDbType.VarChar, -1),
new SqlMetaData("Facebook_Page", SqlDbType.VarChar, -1),
new SqlMetaData("Longitude", SqlDbType.VarChar, -1),
new SqlMetaData("Latitude", SqlDbType.VarChar, -1),
new SqlMetaData("Img1", SqlDbType.VarChar, -1),
new SqlMetaData("Img2", SqlDbType.VarChar, -1),
new SqlMetaData("Img3", SqlDbType.VarChar, -1),
new SqlMetaData("Img4", SqlDbType.VarChar, -1),
new SqlMetaData("Img5", SqlDbType.VarChar, -1),
new SqlMetaData("Isactive", SqlDbType.Bit),
new SqlMetaData("IsAdminAproved", SqlDbType.Bit)
);
foreach (Hall data in this)
{
if (CheckNullOrEmpty(data.Hall_ID))
{
ret.SetDBNull(0);
}
else
{
ret.SetInt32(0, data.Hall_ID);
}
if (CheckNullOrEmpty(data.Hall_Name))
{
ret.SetDBNull(1);
}
else
{
ret.SetString(1, data.Hall_Name);
}
if (CheckNullOrEmpty(data.Username))
{
ret.SetDBNull(2);
}
else
{
ret.SetString(2, data.Username);
}
if (CheckNullOrEmpty(data.Password))
{
ret.SetDBNull(3);
}
else
{
ret.SetString(3, data.Password);
}
if (CheckNullOrEmpty(data.Email))
{
ret.SetDBNull(4);
}
else
{
ret.SetString(4, data.Email);
}
if (CheckNullOrEmpty(data.Country))
{
ret.SetDBNull(5);
}
else
{
ret.SetString(5, data.Country);
}
if (CheckNullOrEmpty(data.City))
{
ret.SetDBNull(6);
}
else
{
ret.SetString(6, data.City);
}
if (CheckNullOrEmpty(data.Capacity))
{
ret.SetDBNull(7);
}
else
{
ret.SetString(7, data.Capacity);
}
if (CheckNullOrEmpty(data.Amount))
{
ret.SetDBNull(8);
}
else
{
ret.SetString(8, data.Amount);
}
if (CheckNullOrEmpty(data.Type))
{
ret.SetDBNull(9);
}
else
{
ret.SetString(9, data.Type);
}
if (CheckNullOrEmpty(data.Office_Contact))
{
ret.SetDBNull(10);
}
else
{
ret.SetString(10, data.Office_Contact);
}
if (CheckNullOrEmpty(data.Office_Hours_From))
{
ret.SetDBNull(11);
}
else
{
ret.SetString(11, data.Office_Hours_From);
}
if (CheckNullOrEmpty(data.Office_Hours_To))
{
ret.SetDBNull(12);
}
else
{
ret.SetString(12, data.Office_Hours_To);
}
if (CheckNullOrEmpty(data.Website_Url))
{
ret.SetDBNull(13);
}
else
{
ret.SetString(13, data.Website_Url);
}
if (CheckNullOrEmpty(data.Facebook_Page))
{
ret.SetDBNull(14);
}
else
{
ret.SetString(14, data.Facebook_Page);
}
if (CheckNullOrEmpty(data.Longitude))
{
ret.SetDBNull(15);
}
else
{
ret.SetString(15, data.Longitude);
}
if (CheckNullOrEmpty(data.Latitude))
{
ret.SetDBNull(16);
}
else
{
ret.SetString(16, data.Latitude);
}
if (CheckNullOrEmpty(data.Img1))
{
ret.SetDBNull(17);
}
else
{
ret.SetString(17, data.Img1);
}
if (CheckNullOrEmpty(data.Img2))
{
ret.SetDBNull(18);
}
else
{
ret.SetString(18, data.Img2);
}
if (CheckNullOrEmpty(data.Img3))
{
ret.SetDBNull(19);
}
else
{
ret.SetString(19, data.Img3);
}
if (CheckNullOrEmpty(data.Img4))
{
ret.SetDBNull(20);
}
else
{
ret.SetString(20, data.Img4);
}
if (CheckNullOrEmpty(data.Img5))
{
ret.SetDBNull(21);
}
else
{
ret.SetString(21, data.Img5);
}
if (CheckNullOrEmpty(data.Isactive))
{
ret.SetDBNull(22);
}
else
{
ret.SetBoolean(22, (Boolean)data.Isactive);
}
if (CheckNullOrEmpty(data.IsAdminAproved))
{
ret.SetDBNull(23);
}
else
{
ret.SetBoolean(23, (Boolean)data.IsAdminAproved);
}
yield return(ret);
}
}
IEnumerator <SqlDataRecord> IEnumerable <SqlDataRecord> .GetEnumerator()
{
var sdr = new SqlDataRecord(
new SqlMetaData("CarouselSlideId", SqlDbType.BigInt),
new SqlMetaData("ImageTenantId", SqlDbType.BigInt),
new SqlMetaData("ThumbnailImageUploadId", SqlDbType.BigInt),
new SqlMetaData("PreviewImageUploadId", SqlDbType.BigInt),
new SqlMetaData("ImageUploadId", SqlDbType.BigInt),
new SqlMetaData("Name", SqlDbType.NVarChar, 256),
new SqlMetaData("Description", SqlDbType.NVarChar, -1),
new SqlMetaData("PageTenantId", SqlDbType.BigInt),
new SqlMetaData("PageId", SqlDbType.BigInt),
new SqlMetaData("PageText", SqlDbType.NVarChar, 50),
new SqlMetaData("SortOrder", SqlDbType.Int)
);
foreach (CarouselSlide carouselSlide in this)
{
if (carouselSlide.CarouselSlideId != 0)
{
sdr.SetInt64(0, carouselSlide.CarouselSlideId);
}
else
{
sdr.SetDBNull(0);
}
sdr.SetInt64(1, carouselSlide.ImageTenantId);
sdr.SetInt64(2, carouselSlide.ThumbnailImageUploadId);
sdr.SetInt64(3, carouselSlide.PreviewImageUploadId);
sdr.SetInt64(4, carouselSlide.ImageUploadId);
if (carouselSlide.Name != null)
{
sdr.SetString(5, carouselSlide.Name);
}
else
{
sdr.SetDBNull(5);
}
if (carouselSlide.Description != null)
{
sdr.SetString(6, carouselSlide.Description);
}
else
{
sdr.SetDBNull(6);
}
if (carouselSlide.PageTenantId.HasValue)
{
sdr.SetInt64(7, carouselSlide.PageTenantId.Value);
}
else
{
sdr.SetDBNull(7);
}
if (carouselSlide.PageId.HasValue)
{
sdr.SetInt64(8, carouselSlide.PageId.Value);
}
else
{
sdr.SetDBNull(8);
}
if (carouselSlide.PageText != null)
{
sdr.SetString(9, carouselSlide.PageText);
}
else
{
sdr.SetDBNull(9);
}
sdr.SetInt32(10, carouselSlide.SortOrder);
yield return(sdr);
}
}
IEnumerator <SqlDataRecord> IEnumerable <SqlDataRecord> .GetEnumerator()
{
var sqlRow = new SqlDataRecord(
new SqlMetaData("Id", SqlDbType.Int),
new SqlMetaData("DataType", SqlDbType.NVarChar, 40),
new SqlMetaData("RuleType", SqlDbType.NVarChar, 40),
new SqlMetaData("RuleParameters", SqlDbType.NVarChar, 500),
new SqlMetaData("RuleKey", SqlDbType.NVarChar, 16),
new SqlMetaData("RuleName", SqlDbType.NVarChar, 40),
new SqlMetaData("RuleFunction", SqlDbType.NVarChar, 255),
new SqlMetaData("DataAttribute", SqlDbType.NVarChar, 255),
new SqlMetaData("RuleFilter", SqlDbType.NVarChar, 255),
new SqlMetaData("FailRule", SqlDbType.NVarChar, 255),
new SqlMetaData("PredictionOrder", SqlDbType.Int),
new SqlMetaData("KeyNumber", SqlDbType.Int),
new SqlMetaData("Active", SqlDbType.NVarChar, 1),
new SqlMetaData("RuleDescription", SqlDbType.NVarChar, 255),
new SqlMetaData("CreatedBy", SqlDbType.NVarChar, 255),
new SqlMetaData("ModifiedBy", SqlDbType.NVarChar, 255),
new SqlMetaData("CreatedDate", SqlDbType.DateTime),
new SqlMetaData("ModifiedDate", SqlDbType.DateTime)
);
foreach (RuleModel rule in this)
{
sqlRow.SetInt32(0, rule.Id);
sqlRow.SetString(1, rule.DataType);
sqlRow.SetString(2, rule.RuleType);
if (rule.RuleParameters == null)
{
sqlRow.SetDBNull(3);
}
else
{
sqlRow.SetString(3, rule.RuleParameters);
}
if (rule.RuleKey == null)
{
sqlRow.SetDBNull(4);
}
else
{
sqlRow.SetString(4, rule.RuleKey);
}
sqlRow.SetString(5, rule.RuleName);
if (rule.RuleFunction == null)
{
sqlRow.SetDBNull(6);
}
else
{
sqlRow.SetString(6, rule.RuleFunction);
}
if (rule.DataAttribute == null)
{
sqlRow.SetDBNull(7);
}
else
{
sqlRow.SetString(7, rule.DataAttribute);
}
if (rule.RuleFilter == null)
{
sqlRow.SetDBNull(8);
}
else
{
sqlRow.SetString(8, rule.RuleFilter);
}
if (rule.FailRule == null)
{
sqlRow.SetDBNull(9);
}
else
{
sqlRow.SetString(9, rule.FailRule);
}
sqlRow.SetInt32(10, rule.PredictionOrder);
sqlRow.SetInt32(11, rule.KeyNumber);
if (rule.Active == null)
{
sqlRow.SetDBNull(12);
}
else
{
sqlRow.SetString(12, rule.Active);
}
if (rule.RuleDescription == null)
{
sqlRow.SetDBNull(13);
}
else
{
sqlRow.SetString(13, rule.RuleDescription);
}
if (rule.CreatedBy == null)
{
sqlRow.SetDBNull(14);
}
else
{
sqlRow.SetString(14, rule.CreatedBy);
}
if (rule.ModifiedBy == null)
{
sqlRow.SetDBNull(15);
}
else
{
sqlRow.SetString(15, rule.ModifiedBy);
}
if (rule.CreatedDate == null)
{
sqlRow.SetDBNull(16);
}
else
{
sqlRow.SetDateTime(16, (DateTime)rule.CreatedDate);
}
if (rule.ModifiedDate == null)
{
sqlRow.SetDBNull(17);
}
else
{
sqlRow.SetDateTime(17, (DateTime)rule.ModifiedDate);
}
yield return(sqlRow);
}
}
public static void GetTable(string connectionString, string tableName)
{
var metaCount = 0;
var fieldNames = new List <string>();
//--use: "Provider=Microsoft.SQLSERVER.MOBILE.OLEDB.3.0;OLE DB Services=-4;" for SQL Compact 3.1
//--use: "Provider=Microsoft.SQLSERVER.CE.OLEDB.3.5;OLE DB Services=-4;" for SQL Compact 3.5 SP2
//--use: "Provider=Microsoft.SQLSERVER.CE.OLEDB.4.0;OLE DB Services=-4;" for SQL Compact 4.0
using (var conn = new OleDbConnection(connectionString))
{
conn.Open();
// determine the number of SqlMetadata parameters needed
using (var cmd = new OleDbCommand())
{
cmd.CommandText = "SELECT COLUMN_NAME, DATA_TYPE FROM INFORMATION_SCHEMA.COLUMNS WHERE TABLE_NAME = @p1 ORDER BY ORDINAL_POSITION";
cmd.Parameters.Add(new OleDbParameter("@p1", OleDbType.VarWChar, 128));
cmd.Parameters[0].Value = tableName;
cmd.Connection = conn;
using (var rdr = cmd.ExecuteReader())
{
while (rdr != null && rdr.Read())
{
//if (SqlContext.Pipe != null) SqlContext.Pipe.Send(rdr[1].ToString());
if (rdr[1].ToString() == "ntext" || rdr[1].ToString() == "image")
{
continue;
}
metaCount++;
fieldNames.Add("[" + rdr[0] + "]");
}
}
}
if (metaCount == 0)
{
if (SqlContext.Pipe != null)
{
SqlContext.Pipe.Send("No data found, or table does not exist");
}
return;
}
//Get the meta data for the fields
var metadata = GetMetaData(metaCount, tableName, conn);
var record = new SqlDataRecord(metadata);
var fields = new System.Text.StringBuilder();
foreach (var field in fieldNames)
{
fields.Append(field);
fields.Append(", ");
}
fields.Remove(fields.Length - 2, 2);
using (var cmd = new OleDbCommand("SELECT " + fields + " FROM [" + tableName + "]", conn))
{
using (var rdr = cmd.ExecuteReader())
{
if (SqlContext.Pipe != null)
{
//SqlContext.Pipe.Send(cmd.CommandText);
SqlContext.Pipe.SendResultsStart(record);
while (rdr != null && rdr.Read())
{
for (var i = 0; i < rdr.FieldCount; i++)
{
if (rdr.IsDBNull(i))
{
record.SetDBNull(i);
}
else
{
if (metadata[i].SqlDbType == SqlDbType.Bit)
{
record.SetBoolean(i, rdr.GetBoolean(i));
}
if (metadata[i].SqlDbType == SqlDbType.TinyInt)
{
record.SetByte(i, rdr.GetByte(i));
}
if (metadata[i].SqlDbType == SqlDbType.SmallInt)
{
record.SetInt16(i, rdr.GetInt16(i));
}
if (metadata[i].SqlDbType == SqlDbType.Int)
{
record.SetInt32(i, rdr.GetInt32(i));
}
if (metadata[i].SqlDbType == SqlDbType.BigInt)
{
record.SetInt64(i, rdr.GetInt64(i));
}
if (metadata[i].SqlDbType == SqlDbType.NVarChar || metadata[i].SqlDbType == SqlDbType.NChar)
{
record.SetString(i, rdr.GetString(i));
}
if (metadata[i].SqlDbType == SqlDbType.UniqueIdentifier)
{
record.SetGuid(i, rdr.GetGuid(i));
}
if (metadata[i].SqlDbType == SqlDbType.Timestamp || metadata[i].SqlDbType == SqlDbType.Binary || metadata[i].SqlDbType == SqlDbType.VarBinary)
{
var tsbuffer = (byte[])rdr[i];
record.SetBytes(i, 0, tsbuffer, 0, tsbuffer.Length);
}
if (metadata[i].SqlDbType == SqlDbType.DateTime)
{
record.SetDateTime(i, rdr.GetDateTime(i));
}
if (metadata[i].SqlDbType == SqlDbType.Money || metadata[i].SqlDbType == SqlDbType.Decimal)
{
record.SetDecimal(i, rdr.GetDecimal(i));
}
if (metadata[i].SqlDbType == SqlDbType.Float)
{
record.SetDouble(i, rdr.GetDouble(i));
}
if (metadata[i].SqlDbType == SqlDbType.Real)
{
record.SetSqlSingle(i, Convert.ToSingle(rdr.GetValue(i)));
}
}
}
//Send the completed record..
SqlContext.Pipe.SendResultsRow(record);
}
if (rdr != null)
{
rdr.Close();
}
SqlContext.Pipe.SendResultsEnd();
}
}
}
conn.Close();
}
}
public static SqlDataRecord Convert(RegisterWxUserContext model)
{
if (model == null)
{
return(null);
}
var record = new SqlDataRecord(DAOConstants.RegisterWeChatUserStructure);
for (var i = 0; i < DAOConstants.RegisterWeChatUserStructure.Length; i++)
{
switch (DAOConstants.RegisterWeChatUserStructure[i].Name)
{
case "UnionId":
record.SetString(i, model.Info.UnionId);
break;
case "AppId":
record.SetString(i, model.WxApp.AppId);
break;
case "OpenId":
record.SetString(i, model.Info.OpenId);
break;
case "RegistrySource":
record.SetInt32(i, (int)model.WxApp.AppType);
break;
case "NickName":
if (string.IsNullOrEmpty(model.Info.NickName))
{
record.SetDBNull(i);
}
else
{
record.SetString(i, model.Info.NickName);
}
break;
case "Country":
if (string.IsNullOrEmpty(model.Info.Country))
{
record.SetDBNull(i);
}
else
{
record.SetString(i, model.Info.Country);
}
break;
case "Province":
if (string.IsNullOrEmpty(model.Info.Province))
{
record.SetDBNull(i);
}
else
{
record.SetString(i, model.Info.Province);
}
break;
case "City":
if (string.IsNullOrEmpty(model.Info.City))
{
record.SetDBNull(i);
}
else
{
record.SetString(i, model.Info.City);
}
break;
case "AvatarUrl":
if (string.IsNullOrEmpty(model.Info.AvatarUrl))
{
record.SetDBNull(i);
}
else
{
record.SetString(i, model.Info.AvatarUrl);
}
break;
case "LastUpdatedBy":
if (string.IsNullOrEmpty(model.LastUpdateBy))
{
record.SetDBNull(i);
}
else
{
record.SetString(i, model.LastUpdateBy);
}
break;
case "ScenarioId":
if (model.ScenarioId == null)
{
record.SetDBNull(i);
}
else
{
record.SetGuid(i, model.ScenarioId.Value);
}
break;
case "SharedBy":
if (string.IsNullOrEmpty(model.SharedBy))
{
record.SetDBNull(i);
}
else
{
record.SetString(i, model.SharedBy);
}
break;
}
}
return(record);
}
IEnumerator <SqlDataRecord> IEnumerable <SqlDataRecord> .GetEnumerator()
{
SqlDataRecord ret = new SqlDataRecord(
new SqlMetaData("DataName", SqlDbType.NVarChar, 40),
new SqlMetaData("IndexNode", SqlDbType.NVarChar, 255),
new SqlMetaData("QcLocation", SqlDbType.NVarChar, 255),
new SqlMetaData("DataType", SqlDbType.NVarChar, 40),
new SqlMetaData("DataKey", SqlDbType.NVarChar, 400),
new SqlMetaData("Latitude", SqlDbType.Float),
new SqlMetaData("Longitude", SqlDbType.Float),
new SqlMetaData("JsonDataObject", SqlDbType.NVarChar, SqlMetaData.Max)
);
foreach (IndexData data in this)
{
ret.SetString(0, data.DataName);
ret.SetString(1, data.IndexNode);
if (data.QcLocation == null)
{
ret.SetDBNull(2);
}
else
{
ret.SetString(2, data.QcLocation);
}
ret.SetString(3, data.DataType);
if (data.DataKey == null)
{
ret.SetDBNull(4);
}
else
{
ret.SetString(4, data.DataKey);
}
if (data.Latitude == null)
{
ret.SetDBNull(5);
}
else
{
ret.SetDouble(5, (double)data.Latitude);
}
if (data.Longitude == null)
{
ret.SetDBNull(6);
}
else
{
ret.SetDouble(6, (double)data.Longitude);
}
if (data.JsonDataObject == null)
{
ret.SetDBNull(7);
}
else
{
ret.SetString(7, data.JsonDataObject);
}
yield return(ret);
}
}
