public ClickHouseTcpClient( TcpClient client, ClickHouseBinaryProtocolReader reader, ClickHouseBinaryProtocolWriter writer, ClickHouseConnectionSettings settings, ClickHouseServerInfo serverInfo, IClickHouseTypeInfoProvider typeInfoProvider) { _reader = reader ?? throw new ArgumentNullException(nameof(reader)); _writer = writer ?? throw new ArgumentNullException(nameof(writer)); _client = client ?? throw new ArgumentNullException(nameof(client)); _settings = settings ?? throw new ArgumentNullException(nameof(settings)); ServerInfo = serverInfo; TypeInfoProvider = typeInfoProvider; }
public IClickHouseColumnTypeInfo GetDetailedTypeInfo(List <ReadOnlyMemory <char> > options, IClickHouseTypeInfoProvider typeInfoProvider) { if (options.Count > 1) { throw new ClickHouseException(ClickHouseErrorCodes.TypeNotSupported, $"Too many arguments in the definition of \"{TypeName}\"."); } var elementTypeInfo = typeInfoProvider.GetTypeInfo(options[0]); return(new ArrayTypeInfo(elementTypeInfo)); }
IClickHouseColumnTypeInfo IClickHouseColumnTypeInfo.GetDetailedTypeInfo(List <ReadOnlyMemory <char> > options, IClickHouseTypeInfoProvider typeInfoProvider) { throw new ClickHouseException(ClickHouseErrorCodes.TypeNotSupported, $"The type \"{TypeName}\" does not support arguments."); }
public IClickHouseColumnTypeInfo GetDetailedTypeInfo(List <ReadOnlyMemory <char> > options, IClickHouseTypeInfoProvider typeInfoProvider) { var parsedOptions = new List <KeyValuePair <string, TValue> >(options.Count); var complexNameBuilder = new StringBuilder(TypeName).Append('('); bool isFirst = true; foreach (var option in options) { if (isFirst) { isFirst = false; } else { complexNameBuilder.Append(", "); } var keyStrLen = ClickHouseSyntaxHelper.GetSingleQuoteStringLength(option.Span); if (keyStrLen < 0) { throw new ClickHouseException(ClickHouseErrorCodes.InvalidTypeName, $"The fragment \"{option}\" is not recognized as an item of the enum."); } var key = ClickHouseSyntaxHelper.GetSingleQuoteString(option.Slice(0, keyStrLen).Span); var valuePart = option.Slice(keyStrLen); var eqSignIdx = valuePart.Span.IndexOf('='); if (eqSignIdx < 0) { throw new ClickHouseException(ClickHouseErrorCodes.InvalidTypeName, $"The fragment \"{option}\" is not recognized as an item of the enum."); } valuePart = valuePart.Slice(eqSignIdx + 1).Trim(); if (!TryParse(valuePart.Span, out var value)) { throw new ClickHouseException(ClickHouseErrorCodes.InvalidTypeName, $"The value {valuePart} is not a valid value of {TypeName}."); } complexNameBuilder.Append(option); parsedOptions.Add(new KeyValuePair <string, TValue>(key, value)); } var complexName = complexNameBuilder.Append(')').ToString(); return(CreateDetailedTypeInfo(complexName, parsedOptions)); }
public IClickHouseColumnTypeInfo GetDetailedTypeInfo(List <ReadOnlyMemory <char> > options, IClickHouseTypeInfoProvider typeInfoProvider) { var parsedOptions = new List <KeyValuePair <string, TValue> >(options.Count); var complexNameBuilder = new StringBuilder(TypeName).Append('('); bool isFirst = true; foreach (var option in options) { if (isFirst) { isFirst = false; } else { complexNameBuilder.Append(", "); } var optionStr = option.ToString(); var match = _enumItemRegex.Match(optionStr); if (!match.Success) { throw new ClickHouseException(ClickHouseErrorCodes.InvalidTypeName, $"The fragment \"{optionStr}\" is not recognized as an item of the enum."); } var key = match.Groups[1].Value; var valueStr = match.Groups[2].Value; if (!TryParse(valueStr, out var value)) { throw new ClickHouseException(ClickHouseErrorCodes.InvalidTypeName, $"The value {valueStr} is not a valid value of {TypeName}."); } complexNameBuilder.Append(optionStr); parsedOptions.Add(new KeyValuePair <string, TValue>(key, value)); } var complexName = complexNameBuilder.Append(')').ToString(); return(CreateDetailedTypeInfo(complexName, parsedOptions)); }
public IClickHouseColumnTypeInfo GetDetailedTypeInfo(List <ReadOnlyMemory <char> > options, IClickHouseTypeInfoProvider typeInfoProvider) { if (_elementTypes != null) { throw new ClickHouseException(ClickHouseErrorCodes.TypeNotSupported, "The type is already fully specified."); } var elementTypes = new List <IClickHouseColumnTypeInfo>(options.Count); elementTypes.AddRange(options.Select(typeInfoProvider.GetTypeInfo)); return(new TupleTypeInfo(elementTypes)); }
public IClickHouseColumnTypeInfo GetDetailedTypeInfo(List <ReadOnlyMemory <char> > options, IClickHouseTypeInfoProvider typeInfoProvider) { if (options.Count > 2) { throw new ClickHouseException(ClickHouseErrorCodes.TypeNotSupported, $"Too many arguments in the definition of \"{TypeName}\"."); } if (!int.TryParse(options[0].Span, NumberStyles.Integer, CultureInfo.InvariantCulture, out var precision)) { throw new ClickHouseException(ClickHouseErrorCodes.InvalidTypeName, $"The first argument (precision) of the type \"{TypeName}\" must be an integer."); } else if (precision < 0) { throw new ClickHouseException(ClickHouseErrorCodes.InvalidTypeName, $"The precision value for the type \"{TypeName}\" must be a non-negative number."); } if (options.Count == 2) { var tzCode = options[1].Trim('\'').ToString(); return(new DateTime64TypeInfo(precision, tzCode, true)); } return(new DateTime64TypeInfo(precision, _timeZoneCode, false)); }
public IClickHouseColumnTypeInfo GetDetailedTypeInfo(List <ReadOnlyMemory <char> > options, IClickHouseTypeInfoProvider typeInfoProvider) { if (_elementTypes != null) { throw new ClickHouseException(ClickHouseErrorCodes.TypeNotSupported, "The type is already fully specified."); } var complexTypeNameBuilder = new StringBuilder(TypeName).Append('('); var elementTypes = new List <IClickHouseColumnTypeInfo>(options.Count); List <string>?elementNames = null; foreach (var option in options) { if (elementTypes.Count > 0) { complexTypeNameBuilder.Append(", "); } var identifierLen = ClickHouseSyntaxHelper.GetIdentifierLiteralLength(option.Span); if (identifierLen == option.Span.Length) { identifierLen = -1; } if (identifierLen < 0) { if (elementNames != null) { throw new ClickHouseException(ClickHouseErrorCodes.InvalidTypeName, "A tuple can be either named or not. Mixing of named and unnamed arguments is not allowed."); } var typeInfo = typeInfoProvider.GetTypeInfo(option); elementTypes.Add(typeInfo); } else { if (elementNames == null) { if (elementTypes.Count > 0) { throw new ClickHouseException(ClickHouseErrorCodes.InvalidTypeName, "A tuple can be either named or not. Mixing of named and unnamed arguments is not allowed."); } elementNames = new List <string>(options.Count); } var name = ClickHouseSyntaxHelper.GetIdentifier(option.Span.Slice(0, identifierLen)); var typeInfo = typeInfoProvider.GetTypeInfo(option.Slice(identifierLen + 1)); elementTypes.Add(typeInfo); elementNames.Add(name); complexTypeNameBuilder.Append(option.Slice(0, identifierLen)).Append(' '); } complexTypeNameBuilder.Append(elementTypes[^ 1].ComplexTypeName);
public IClickHouseColumnTypeInfo GetDetailedTypeInfo(List <ReadOnlyMemory <char> > options, IClickHouseTypeInfoProvider typeInfoProvider) { if (_baseType != null) { throw new ClickHouseException(ClickHouseErrorCodes.TypeNotSupported, "The type is already fully specified."); } if (options.Count > 1) { throw new ClickHouseException(ClickHouseErrorCodes.TypeNotSupported, $"Too many arguments in the definition of \"{TypeName}\"."); } var baseType = typeInfoProvider.GetTypeInfo(options[0]); return(new LowCardinalityTypeInfo(baseType)); }
public IClickHouseColumnTypeInfo GetDetailedTypeInfo(List <ReadOnlyMemory <char> > options, IClickHouseTypeInfoProvider typeInfoProvider) { if (_length != null) { throw new ClickHouseException(ClickHouseErrorCodes.TypeNotSupported, "The type is already fully specified."); } if (options.Count > 1) { throw new ClickHouseException(ClickHouseErrorCodes.TypeNotSupported, $"Too many arguments in the definition of \"{TypeName}\"."); } if (!int.TryParse(options[0].Span, NumberStyles.Integer, CultureInfo.InvariantCulture, out var length) || length <= 0) { throw new ClickHouseException(ClickHouseErrorCodes.TypeNotSupported, $"The length of \"{TypeName}({options[0].ToString()})\" must be a positive number."); } return(new FixedStringTypeInfo(length)); }
public IClickHouseColumnTypeInfo GetDetailedTypeInfo(List <ReadOnlyMemory <char> > options, IClickHouseTypeInfoProvider typeInfoProvider) { int?precision = null; int scale; if (options.Count == 1) { if (!int.TryParse(options[0].Span, NumberStyles.Integer, CultureInfo.InvariantCulture, out scale) || scale < 0) { throw new ClickHouseException(ClickHouseErrorCodes.InvalidTypeName, $"The scale value for the type \"{TypeName}\" must be a non-negative number."); } } else if (options.Count == 2) { if (!int.TryParse(options[0].Span, NumberStyles.Integer, CultureInfo.InvariantCulture, out var firstValue) || firstValue <= 0) { throw new ClickHouseException(ClickHouseErrorCodes.InvalidTypeName, $"The first parameter in options (precision) for the type \"{TypeName}\" must be a positive number."); } precision = firstValue; if (!int.TryParse(options[1].Span, NumberStyles.Integer, CultureInfo.InvariantCulture, out scale) || scale < 0) { throw new ClickHouseException(ClickHouseErrorCodes.InvalidTypeName, $"The second parameter in options (scale) for the type \"{TypeName}\" must be a non-negative number."); } } else { throw new ClickHouseException(ClickHouseErrorCodes.InvalidTypeName, $"Too many options for the type \"{TypeName}\"."); } if (_precision != null && precision != null) { throw new ClickHouseException(ClickHouseErrorCodes.InvalidTypeName, $"The value of the precision can not be redefined for the type \"{TypeName}\"."); } var complexTypeName = TypeName + "(" + string.Join(", ", options) + ")"; return(CloneWithOptions(complexTypeName, precision, scale)); }
public IClickHouseColumnTypeInfo GetDetailedTypeInfo(List <ReadOnlyMemory <char> > options, IClickHouseTypeInfoProvider typeInfoProvider) { if (options.Count > 1) { throw new ClickHouseException(ClickHouseErrorCodes.TypeNotSupported, $"Too many arguments in the definition of \"{TypeName}\"."); } var tzCode = options[0].Trim('\'').ToString(); return(new DateTimeTypeInfo(tzCode, true)); }
public IClickHouseColumnTypeInfo GetDetailedTypeInfo(List <ReadOnlyMemory <char> > options, IClickHouseTypeInfoProvider typeInfoProvider) { if (_typeArgs != null) { throw new ClickHouseException(ClickHouseErrorCodes.TypeNotSupported, "The type is already fully specified."); } if (options.Count < 2) { throw new ClickHouseException(ClickHouseErrorCodes.InvalidTypeName, $"The type \"{TypeName}\" requires two type arguments: key and value."); } if (options.Count > 2) { throw new ClickHouseException(ClickHouseErrorCodes.InvalidTypeName, $"Too many options for the type \"{TypeName}\"."); } var keyType = typeInfoProvider.GetTypeInfo(options[0]); var valueType = typeInfoProvider.GetTypeInfo(options[1]); var underlyingTypeName = $"Array(Tuple({keyType.ComplexTypeName}, {valueType.ComplexTypeName}))"; var undelyingType = typeInfoProvider.GetTypeInfo(underlyingTypeName); return(new MapTypeInfo(keyType, valueType, undelyingType)); }