public static SqlChars ConvertToPinyin(SqlChars input) { if (input.IsNull) return input; var str = new string(input.Value); return new SqlChars(StringConverter.GetChineseSpell(str)); }
public static SqlChars RegexGroup( SqlChars input, SqlString pattern, SqlString name ) { Regex regex = new Regex( pattern.Value, Options ); Match match = regex.Match( new string( input.Value ) ); return match.Success ? new SqlChars( match.Groups[name.Value].Value ) : SqlChars.Null; }
public static void FillMatch(object obj, out int index, out int length, out SqlChars value) { Match match = (Match)obj; index = match.Index; length = match.Length; value = new SqlChars(match.Value); }
public static void FillMatchRow( object data, out SqlInt32 index, out SqlChars text ) { MatchNode node = (MatchNode)data; index = new SqlInt32( node.Index ); text = new SqlChars( node.Value.ToCharArray( ) ); }
public void SqlCharsItem () { SqlChars chars = new SqlChars (); try { Assert.AreEqual (chars [0], 0, "#1 Should throw SqlNullValueException"); Assert.Fail ("Should throw SqlNullValueException"); } catch (Exception ex) { Assert.AreEqual (typeof (SqlNullValueException), ex.GetType (), "Should throw SqlNullValueException"); } char [] b = null; chars = new SqlChars (b); try { Assert.AreEqual (chars [0], 0, "#2 Should throw SqlNullValueException"); Assert.Fail ("Should throw SqlNullValueException"); } catch (Exception ex) { Assert.AreEqual (typeof (SqlNullValueException), ex.GetType (), "Should throw SqlNullValueException"); } b = new char [10]; chars = new SqlChars (b); Assert.AreEqual (chars [0], 0, ""); try { Assert.AreEqual (chars [-1], 0, ""); Assert.Fail ("Should throw ArgumentOutOfRangeException"); } catch (Exception ex) { Assert.AreEqual (typeof (ArgumentOutOfRangeException), ex.GetType (), "Should throw ArgumentOutOfRangeException"); } try { Assert.AreEqual (chars [10], 0, ""); Assert.Fail ("Should throw ArgumentOutOfRangeException"); } catch (Exception ex) { Assert.AreEqual (typeof (ArgumentOutOfRangeException), ex.GetType (), "Should throw ArgumentOutOfRangeException"); } }
internal static SqlString TrimEnd(SqlString src, SqlChars des) { if (IsAllNull(des)) return src; if (IsAllNull(src)) return SqlString.Null; string _s = src.Value; return new SqlString(_s.TrimEnd(des.Value)); }
public static SqlString RegexReplace(SqlChars input, SqlString pattern, SqlChars replacement) { Regex regex = new Regex(pattern.Value, Options); return regex.Replace(new string(input.Value),new string(replacement.Value)); ///return regex.IsMatch(new string(input.Value)); ///The SQL datatype here is a BIT }
override public void SetCapacity(int capacity) { SqlChars[] newValues = new SqlChars[capacity]; if (null != values) { Array.Copy(values, 0, newValues, 0, Math.Min(capacity, values.Length)); } values = newValues; }
/// <summary> /// FillRow method to populate the output table /// </summary> /// <param name=”obj”>RegExRow passed as object</param> /// <param name=”rowId”>ID or the returned row</param> /// <param name=”matchId”>ID of returned Match</param> /// <param name=”groupID”>ID of group in the Match</param> /// <param name=”value”>Value of the Group</param> public static void FillRegExRow( Object obj, out int rowId, out int matchId, out int groupID, out SqlChars value ) { RegExRow r = (RegExRow)obj; rowId = r.RowId; matchId = r.MatchId; groupID = r.GroupID; value = new SqlChars( r.Value ); }
public static void FillGroupRow( object data, out SqlInt32 index, out SqlChars group, out SqlChars text ) { GroupNode node = (GroupNode)data; index = new SqlInt32( node.Index ); group = new SqlChars( node.Name.ToCharArray( ) ); text = new SqlChars( node.Value.ToCharArray( ) ); }
public static void FillRow(Object obj, out SqlDateTime timeWritten, out SqlChars message, out SqlChars category, out long instanceId) { EventLogEntry eventLogEntry = (EventLogEntry)obj; timeWritten = new SqlDateTime(eventLogEntry.TimeWritten); message = new SqlChars(eventLogEntry.Message); category = new SqlChars(eventLogEntry.Category); instanceId = eventLogEntry.InstanceId; }
public static void FillAdjustedPrice(Object obj, out SqlInt32 itemId, out SqlMoney adjustedPrice, out SqlMoney averagePrice, out SqlChars itemName) { CCPDatum Item = (CCPDatum)obj; itemId = new SqlInt32(Item.item_id); adjustedPrice = new SqlMoney(Item.adjustedPrice); averagePrice = Item.averagePrice.HasValue ? new SqlMoney(Item.averagePrice.Value) : SqlMoney.Null; itemName = new SqlChars(Item.item_name); }
/// <summary> /// 把每个值进行累加 /// </summary> /// <param name="value"></param> public void Accumulate(SqlChars value, SqlString connector) { if (value.IsNull) return; if (splitterLength == 0) splitterLength = (connector.IsNull ? "," : connector.Value).Length; // 在此处放置代码 result.Append(value.Value).Append(connector.IsNull ? "," : connector.Value); }
public static SqlChars ConvertToTraditionalChinese(SqlChars input) { if (input.IsNull) return input; var str = new string(input.Value); // 在此处放置代码 return new SqlChars(Strings.StrConv(str, VbStrConv.TraditionalChinese, 0)); }
public static SqlChars ConvertToProperCase(SqlChars input) { if (input.IsNull) return input; var str = new string(input.Value); // 在此处放置代码 return new SqlChars(Strings.StrConv(str, VbStrConv.ProperCase, 0)); }
internal static SqlString TrimStartAndEnd(SqlString src, SqlChars startDes, SqlChars endDes) { if (IsAllNull(startDes, endDes)) return src; if (IsAllNull(src)) return SqlString.Null; string _s = src.Value; if (!endDes.IsNull) _s = _s.TrimEnd(endDes.Value); if (!startDes.IsNull) _s = _s.TrimStart(startDes.Value); return new SqlString(_s); }
public static SqlString RegexReplaceRecursive(SqlChars input, SqlString pattern, SqlChars replacement) { string output = new string( input.Value ); Regex regex = new Regex(pattern.Value, Options); while (regex.IsMatch( output )) { output = regex.Replace(output, new string(replacement.Value)); } return output; }
public static SqlBoolean ContainsAny(SqlChars input, string search) { string strTemp = new string(input.Value); foreach (string item in search.Split(',')) { if (strTemp.Contains(item)) { return true; } } return false; }
public static SqlString ToSafeFileNameWith(SqlString text, SqlChars substitution) { if (text.IsNull || String.IsNullOrWhiteSpace(text.Value)) return SqlString.Null; var textValue = text.Value.Trim(); var substitutionChar = substitution.Value[0]; var fileName = Path.GetInvalidFileNameChars().Aggregate(textValue, (current, c) => current.Replace(c, substitutionChar)); return new SqlString(fileName, text.LCID); }
public static SqlChars PadRight(SqlChars input, SqlInt32 totalWidth, char paddingChar) { if (input.IsNull) return input; if (paddingChar == (char)0) return input; if (totalWidth.IsNull || totalWidth < 0) totalWidth = 0; // 在此处放置代码 return new SqlChars(new string(input.Value).PadRight(totalWidth.Value, paddingChar)); }
public void SqlCharsItem() { SqlChars chars = new SqlChars(); try { Assert.Equal(chars[0], 0); Assert.False(true); } catch (Exception ex) { Assert.Equal(typeof(SqlNullValueException), ex.GetType()); } char[] b = null; chars = new SqlChars(b); try { Assert.Equal(chars[0], 0); Assert.False(true); } catch (Exception ex) { Assert.Equal(typeof(SqlNullValueException), ex.GetType()); } b = new char[10]; chars = new SqlChars(b); Assert.Equal(chars[0], 0); try { Assert.Equal(chars[-1], 0); Assert.False(true); } catch (Exception ex) { Assert.Equal(typeof(ArgumentOutOfRangeException), ex.GetType()); } try { Assert.Equal(chars[10], 0); Assert.False(true); } catch (Exception ex) { Assert.Equal(typeof(ArgumentOutOfRangeException), ex.GetType()); } }
public static IEnumerable SplitString(SqlChars input, SqlChars splitter) { string[] array; if (input.IsNull) { array = new string[] { null }; } else if (splitter.IsNull) { array = new string[] { input.ToSqlString().Value }; } else { string inputStr = input.ToSqlString().Value; string sepStr = splitter.ToSqlString().Value; string[] separatorsArray = sepStr.Split(new char[] { '|' }, StringSplitOptions.RemoveEmptyEntries); array = inputStr.Split(separatorsArray, StringSplitOptions.RemoveEmptyEntries); } return array; }
public static SqlString Escaped(SqlString text, SqlChars escapeChar) { if (text.IsNull || String.IsNullOrWhiteSpace(text.Value)) return SqlString.Null; if (escapeChar.IsNull || escapeChar.Length != 1) throw new SqlTypeException("Escape character length must be 1."); var wildcards = new[] {'%', '_', '[', ']'}; char escapeCh = escapeChar.Value[0]; var output = new StringBuilder(); foreach (char ch in text.Value) { if (wildcards.Contains(ch)) output.Append(escapeCh); output.Append(ch); } return new SqlString(output.ToString(), text.LCID); }
public static SqlBoolean RegexMatch( SqlChars input, SqlString pattern) { if (input == null || pattern == null || input.IsNull || pattern.IsNull) return false; try { Regex regex = new Regex(pattern.Value, Options); return regex.IsMatch(new string(input.Value)); } catch (ArgumentException aEx) { return false; } //catch (ArgumentOutOfRangeException aEx) //{ // return false; //} return false; }
protected override void Dispose(bool disposing) { // When m_sqlchars is null, it means the stream has been closed, and // any opearation in the future should fail. // This is the only case that m_sqlchars is null. m_sqlchars = null; }
// -------------------------------------------------------------- // Constructor(s) // -------------------------------------------------------------- internal StreamOnSqlChars(SqlChars s) { m_sqlchars = s; m_lPosition = 0; }
public SqlChars Adjust(SqlChars value) { if (SqlDbType.Char == SqlDbType || SqlDbType.NChar == SqlDbType) { //DBG.Assert(Max!=MaxLength, "SqlMetaData.Adjust(SqlChars): Fixed-length type with Max length!"); // Don't pad null values if (null != value && !value.IsNull) { // Pad fixed-length types long oldLength = value.Length; if (oldLength < MaxLength) { // Make sure buffer is long enough if (value.MaxLength < MaxLength) { char[] rgchNew = new char[(int)MaxLength]; Array.Copy(value.Buffer, 0, rgchNew, 0, (int)oldLength); value = new SqlChars(rgchNew); } // pad extra space char[] rgchTemp = value.Buffer; for (long i = oldLength; i < MaxLength; i++) rgchTemp[i] = ' '; value.SetLength(MaxLength); return value; } } } else if (SqlDbType.VarChar != SqlDbType && SqlDbType.NVarChar != SqlDbType && SqlDbType.Text != SqlDbType && SqlDbType.NText != SqlDbType) ThrowInvalidType(); // Handle null values after type check. if (null == value || value.IsNull) { return value; } // trim all types if (value.Length > MaxLength && Max != MaxLength) value.SetLength(MaxLength); return value; }
internal static SqlChars GetSqlChars( SmiEventSink_Default sink, ITypedGettersV3 getters, int ordinal, SmiMetaData metaData, SmiContext context ) { SqlChars result; if ( CanAccessGetterDirectly( metaData, ExtendedClrTypeCode.SqlChars ) ) { if ( IsDBNull_Unchecked( sink, getters, ordinal ) ) { result = SqlChars.Null; } else { long length = GetCharsLength_Unchecked( sink, getters, ordinal ); if ( length < __maxCharChunkSize || !InOutOfProcHelper.InProc) { char[] charBuffer = GetCharArray_Unchecked( sink, getters, ordinal ); result = new SqlChars( charBuffer ); } else { // InProc only Stream s = new SmiGettersStream( sink, getters, ordinal, metaData ); SqlStreamChars sc = CopyIntoNewSmiScratchStreamChars( s, sink, context ); result = new SqlChars( sc ); } } } else { SqlString stringValue; if (SqlDbType.Xml == metaData.SqlDbType) { SqlXml xmlValue = GetSqlXml_Unchecked( sink, getters, ordinal, null ); if (xmlValue.IsNull) { result = SqlChars.Null; } else { result = new SqlChars( xmlValue.Value.ToCharArray() ); } } else { object obj = GetSqlValue( sink, getters, ordinal, metaData, null ); if (null == obj) { throw ADP.InvalidCast(); } stringValue = (SqlString) obj; if ( stringValue.IsNull ) { result = SqlChars.Null; } else { result = new SqlChars( stringValue.Value.ToCharArray() ); } } } return result; }
private static void SetSqlChars_Unchecked( SmiEventSink_Default sink, ITypedSettersV3 setters, int ordinal, SqlChars value, int offset, int length ) { if ( value.IsNull ) { setters.SetDBNull( sink, ordinal ); sink.ProcessMessagesAndThrow(); } else { int chunkSize; if ( length > __maxCharChunkSize || length < 0 ) { chunkSize = __maxCharChunkSize; } else { chunkSize = checked( (int)length ); } char[] buffer = new char[ chunkSize ]; long charsRead; long charsWritten = 1; // prime value to get into write loop long currentOffset = offset; long lengthWritten = 0; while ( (length < 0 || lengthWritten < length) && 0 != ( charsRead = value.Read( currentOffset, buffer, 0, chunkSize ) ) && 0 != charsWritten ) { charsWritten = setters.SetChars( sink, ordinal, currentOffset, buffer, 0, checked( (int) charsRead ) ); sink.ProcessMessagesAndThrow(); checked{ currentOffset += charsWritten; } checked{ lengthWritten += charsWritten;} } // Make sure to trim any left-over data setters.SetCharsLength( sink, ordinal, currentOffset ); sink.ProcessMessagesAndThrow(); } }
private static void SetSqlChars_LengthChecked( SmiEventSink_Default sink, ITypedSettersV3 setters, int ordinal, SmiMetaData metaData, SqlChars value, int offset ) { int length = 0; if ( !value.IsNull ) { // Deal with large values by sending bufferLength of NoLengthLimit // CheckXetParameters will ignore length checks in this case long bufferLength = value.Length; if ( bufferLength > Int32.MaxValue ) { bufferLength = NoLengthLimit; } length = CheckXetParameters( metaData.SqlDbType, metaData.MaxLength, NoLengthLimit /* actual */, 0, checked( (int) bufferLength ), offset, checked( (int) bufferLength - offset ) ); } SetSqlChars_Unchecked( sink, setters, ordinal, value, 0, length ); }
protected override void Dispose(bool disposing) { this.m_sqlchars = null; }
internal StreamOnSqlChars(SqlChars s) { this.m_sqlchars = s; this.m_lPosition = 0L; }
// -------------------------------------------------------------- // Constructor(s) // -------------------------------------------------------------- internal StreamOnSqlChars(SqlChars s) { _sqlchars = s; _lPosition = 0; }