Showing preview only (2,061K chars total). Download the full file or copy to clipboard to get everything.
Repository: Octonica/ClickHouseClient
Branch: master
Commit: bdd073c40dea
Files: 265
Total size: 1.9 MB
Directory structure:
gitextract_vv1_tqul/
├── .gitignore
├── CHANGELOG.md
├── LICENSE
├── README.md
├── docs/
│ ├── ClickHouseColumnWriter.md
│ ├── Parameters.md
│ └── TypeMapping.md
└── src/
├── ConnectionSettingsHelper.cs
├── Octonica.ClickHouseClient/
│ ├── ClickHouseBinaryProtocolReader.cs
│ ├── ClickHouseBinaryProtocolWriter.cs
│ ├── ClickHouseColumnSettings.cs
│ ├── ClickHouseColumnWriter.cs
│ ├── ClickHouseCommand.cs
│ ├── ClickHouseConnection.cs
│ ├── ClickHouseConnectionSettings.cs
│ ├── ClickHouseConnectionState.cs
│ ├── ClickHouseConnectionStringBuilder.cs
│ ├── ClickHouseDataReader.cs
│ ├── ClickHouseDataReaderBase.cs
│ ├── ClickHouseDataReaderRowLimit.cs
│ ├── ClickHouseDataReaderState.cs
│ ├── ClickHouseDbProviderFactory.cs
│ ├── ClickHouseDbType.cs
│ ├── ClickHouseFlushMode.cs
│ ├── ClickHouseParameter.cs
│ ├── ClickHouseParameterCollection.cs
│ ├── ClickHouseParameterMode.cs
│ ├── ClickHousePasswordComplexityRule.cs
│ ├── ClickHouseQueryExecutionProgress.cs
│ ├── ClickHouseReaderColumnSettings.cs
│ ├── ClickHouseServerInfo.cs
│ ├── ClickHouseTable.cs
│ ├── ClickHouseTableColumn.cs
│ ├── ClickHouseTableColumnCollection.cs
│ ├── ClickHouseTableProvider.cs
│ ├── ClickHouseTableProviderCollection.cs
│ ├── ClickHouseTableWriter.cs
│ ├── ClickHouseTcpClient.cs
│ ├── ClickHouseTcpClientState.cs
│ ├── ClickHouseTlsMode.cs
│ ├── ClickHouseVersion.cs
│ ├── Exceptions/
│ │ ├── ClickHouseErrorCodes.cs
│ │ ├── ClickHouseException.cs
│ │ ├── ClickHouseHandledException.cs
│ │ └── ClickHouseServerException.cs
│ ├── IClickHouseArrayTableColumn.cs
│ ├── IClickHouseColumnDescriptor.cs
│ ├── IClickHouseSessionExternalResources.cs
│ ├── IClickHouseTableColumn.cs
│ ├── IClickHouseTableColumnDispatcher.cs
│ ├── IClickHouseTableProvider.cs
│ ├── Octonica.ClickHouseClient.csproj
│ ├── Properties/
│ │ └── AssemblyInfo.cs
│ ├── Protocol/
│ │ ├── BlockFieldCodes.cs
│ │ ├── BlockHeader.cs
│ │ ├── CityHash.cs
│ │ ├── ClickHouseEmptyTableWriter.cs
│ │ ├── ClickHouseParameterWriter.cs
│ │ ├── ClickHouseProtocolRevisions.cs
│ │ ├── ClickHouseSyntaxHelper.cs
│ │ ├── ClientHelloMessage.cs
│ │ ├── ClientMessageCode.cs
│ │ ├── ClientQueryMessage.cs
│ │ ├── ColumnInfo.cs
│ │ ├── CompressionAlgorithm.cs
│ │ ├── CompressionDecoderBase.cs
│ │ ├── CompressionEncoderBase.cs
│ │ ├── IClickHouseColumnReader.cs
│ │ ├── IClickHouseColumnReaderBase.cs
│ │ ├── IClickHouseColumnWriter.cs
│ │ ├── IClickHouseColumnWriterFactory.cs
│ │ ├── IClickHouseParameterValueWriter.cs
│ │ ├── IClickHouseParameterWriter.cs
│ │ ├── IClickHouseTableWriter.cs
│ │ ├── IClientMessage.cs
│ │ ├── IServerMessage.cs
│ │ ├── Lz4CompressionDecoder.cs
│ │ ├── Lz4CompressionEncoder.cs
│ │ ├── QueryKind.cs
│ │ ├── SequenceSize.cs
│ │ ├── ServerDataMessage.cs
│ │ ├── ServerEndOfStreamMessage.cs
│ │ ├── ServerErrorMessage.cs
│ │ ├── ServerHelloMessage.cs
│ │ ├── ServerMessageCode.cs
│ │ ├── ServerPongMessage.cs
│ │ ├── ServerProfileInfoMessage.cs
│ │ ├── ServerProgressMessage.cs
│ │ ├── ServerTableColumnsMessage.cs
│ │ ├── ServerTimeZoneUpdateMessage.cs
│ │ ├── StateCodes.cs
│ │ └── UnknownServerMessage.cs
│ ├── Types/
│ │ ├── ArrayTableColumn.cs
│ │ ├── ArrayTypeInfo.cs
│ │ ├── BigIntegerTableColumn.cs
│ │ ├── BigIntegerTypeInfoBase.cs
│ │ ├── BoolTableColumn.cs
│ │ ├── BoolTypeInfo.cs
│ │ ├── ClickHouseColumnReinterpreter.cs
│ │ ├── ClickHouseColumnSerializationMode.cs
│ │ ├── ClickHouseEnumConverter.cs
│ │ ├── ClickHouseTableColumnHelper.cs
│ │ ├── ClickHouseTypeInfoProvider.cs
│ │ ├── CustomSerializationColumnReader.cs
│ │ ├── CustomSerializationSkippingColumnReader.cs
│ │ ├── Date32TableColumn.Net6.0.cs
│ │ ├── Date32TableColumn.NetCoreApp3.1.cs
│ │ ├── Date32TableColumn.cs
│ │ ├── Date32TypeInfo.Net6.0.cs
│ │ ├── Date32TypeInfo.NetCoreApp3.1.cs
│ │ ├── Date32TypeInfo.cs
│ │ ├── DateOnlyTableColumn.cs
│ │ ├── DateTime64TableColumn.cs
│ │ ├── DateTime64TypeInfo.cs
│ │ ├── DateTimeTableColumn.cs
│ │ ├── DateTimeTypeInfo.cs
│ │ ├── DateTypeInfo.Net6.0.cs
│ │ ├── DateTypeInfo.NetCoreApp3.1.cs
│ │ ├── DateTypeInfo.cs
│ │ ├── Decimal128TypeInfo.cs
│ │ ├── Decimal32TypeInfo.cs
│ │ ├── Decimal64TypeInfo.cs
│ │ ├── DecimalTableColumn.cs
│ │ ├── DecimalTypeInfo.cs
│ │ ├── DecimalTypeInfoBase.cs
│ │ ├── EmptyParameterValueWriter.cs
│ │ ├── Enum16TypeInfo.cs
│ │ ├── Enum8TypeInfo.cs
│ │ ├── EnumTableColumn.cs
│ │ ├── EnumTypeInfoBase.cs
│ │ ├── FixedStringDecodedCharArrayTableColumn.cs
│ │ ├── FixedStringDecodedTableColumn.cs
│ │ ├── FixedStringTableColumn.cs
│ │ ├── FixedStringTableColumnBase.cs
│ │ ├── FixedStringTypeInfo.cs
│ │ ├── Float32TableColumn.cs
│ │ ├── Float32TypeInfo.cs
│ │ ├── Float64TypeInfo.cs
│ │ ├── HexStringLiteralValueWriter.cs
│ │ ├── HexStringLiteralWriterCastMode.cs
│ │ ├── HexStringParameterWriter.cs
│ │ ├── IClickHouseColumnReinterpreter.cs
│ │ ├── IClickHouseColumnTypeDescriptor.cs
│ │ ├── IClickHouseColumnTypeInfo.cs
│ │ ├── IClickHouseConfigurableTypeInfo.cs
│ │ ├── IClickHouseEnumConverter.cs
│ │ ├── IClickHouseReinterpretedTableColumn.cs
│ │ ├── IClickHouseTypeInfo.cs
│ │ ├── IClickHouseTypeInfoProvider.cs
│ │ ├── Int128TypeInfo.cs
│ │ ├── Int16TableColumn.cs
│ │ ├── Int16TypeInfo.cs
│ │ ├── Int256TypeInfo.cs
│ │ ├── Int32TableColumn.cs
│ │ ├── Int32TypeInfo.cs
│ │ ├── Int64TypeInfo.cs
│ │ ├── Int8TableColumn.cs
│ │ ├── Int8TypeInfo.cs
│ │ ├── IntermediateClickHouseTypeInfo.cs
│ │ ├── IpColumnReaderBase.cs
│ │ ├── IpV4TableColumn.cs
│ │ ├── IpV4TypeInfo.cs
│ │ ├── IpV6TableColumn.cs
│ │ ├── IpV6TypeInfo.cs
│ │ ├── KeyValuePairTableColumn.cs
│ │ ├── LowCardinalityTableColumn.cs
│ │ ├── LowCardinalityTypeInfo.cs
│ │ ├── MapTypeInfo.cs
│ │ ├── NothingTableColumn.cs
│ │ ├── NothingTypeInfo.cs
│ │ ├── NullableTableColumn.cs
│ │ ├── NullableTypeInfo.cs
│ │ ├── ObjectColumnAdapter.cs
│ │ ├── ReinterpretedArrayTableColumn.cs
│ │ ├── ReinterpretedObjectTableColumn.cs
│ │ ├── ReinterpretedTableColumn.cs
│ │ ├── SimpleLiteralValueWriter.cs
│ │ ├── SimpleParameterWriter.cs
│ │ ├── SimpleSkippingColumnReader.cs
│ │ ├── SimpleTypeInfo.cs
│ │ ├── SparseColumn.cs
│ │ ├── StringByteArrayTableColumn.cs
│ │ ├── StringCharArrayTableColumn.cs
│ │ ├── StringLiteralValueWriter.cs
│ │ ├── StringParameterWriter.cs
│ │ ├── StringTableColumn.cs
│ │ ├── StringTableColumnBase.cs
│ │ ├── StringTypeInfo.cs
│ │ ├── StructureReaderBase.cs
│ │ ├── StructureTableColumn.cs
│ │ ├── StructureWriterBase.cs
│ │ ├── TupleTableColumn.cs
│ │ ├── TupleTypeInfo.cs
│ │ ├── UInt128TypeInfo.cs
│ │ ├── UInt16TableColumn.cs
│ │ ├── UInt16TypeInfo.cs
│ │ ├── UInt256TypeInfo.cs
│ │ ├── UInt32TableColumn.cs
│ │ ├── UInt32TypeInfo.cs
│ │ ├── UInt64TypeInfo.cs
│ │ ├── UInt8TableColumn.cs
│ │ ├── UInt8TypeInfo.cs
│ │ ├── UuidTypeInfo.cs
│ │ ├── VariantTableColumn.cs
│ │ └── VariantTypeInfo.cs
│ └── Utils/
│ ├── CertificateHelper.Net5.0.cs
│ ├── CertificateHelper.NetCoreApp3.1.cs
│ ├── CertificateHelper.cs
│ ├── CommonUtils.cs
│ ├── ConstantReadOnlyList.cs
│ ├── FunctionHelper.cs
│ ├── ICollectionList.cs
│ ├── IConverter.cs
│ ├── IConverterDispatcher.cs
│ ├── IReadOnlyListExt.cs
│ ├── ITypeDispatcher.cs
│ ├── IndexedCollectionBase.cs
│ ├── ListExtensions.cs
│ ├── ListSpan.cs
│ ├── MappedListSpan.cs
│ ├── MappedReadOnlyList.cs
│ ├── MappedReadOnlyListSpan.cs
│ ├── MemoryCollectionList.cs
│ ├── MultiDimensionalArrayReadOnlyListAdapter.cs
│ ├── ReadOnlyCollectionList.cs
│ ├── ReadOnlyListSpan.cs
│ ├── ReadOnlyMemoryCollectionList.cs
│ ├── ReadOnlyMemoryList.cs
│ ├── ReadWriteBuffer.cs
│ ├── SimpleReadOnlySequenceSegment.cs
│ ├── TaskHelper.cs
│ ├── TimeZoneHelper.Net6.0.cs
│ ├── TimeZoneHelper.NetCoreApp3.1.cs
│ ├── TimeZoneHelper.cs
│ └── TypeDispatcher.cs
├── Octonica.ClickHouseClient.Benchmarks/
│ ├── ColumnWriterBenchmarks.cs
│ ├── InsertRowBenchmark.cs
│ ├── Octonica.ClickHouseClient.Benchmarks.csproj
│ └── Program.cs
├── Octonica.ClickHouseClient.Tests/
│ ├── AsyncTestFibSequence.cs
│ ├── CityHashTests.Data.cs
│ ├── CityHashTests.cs
│ ├── ClickHouseColumnWriterTests.cs
│ ├── ClickHouseCommandTests.cs
│ ├── ClickHouseConnectionStringBuilderTests.cs
│ ├── ClickHouseConnectionTests.cs
│ ├── ClickHouseDataReaderTests.cs
│ ├── ClickHouseDbProviderFactoryTests.cs
│ ├── ClickHouseParameterCollectionTests.cs
│ ├── ClickHouseParameterTests.cs
│ ├── ClickHouseTestsBase.cs
│ ├── ClickHouseTypeInfoTests.cs
│ ├── CommonUtilsTests.cs
│ ├── EncodingFixture.cs
│ ├── IndexedCollectionTests.cs
│ ├── ListExtensionsTests.cs
│ ├── Octonica.ClickHouseClient.Tests.csproj
│ ├── ReadWriteBufferTests.cs
│ ├── TestBox.cs
│ ├── TestEnum.cs
│ ├── TestIndexedCollection.cs
│ ├── TestListWrappers.cs
│ ├── TypeTests.cs
│ └── xunit.runner.json
└── Octonica.ClickHouseClient.sln
================================================
FILE CONTENTS
================================================
================================================
FILE: .gitignore
================================================
## Ignore Visual Studio temporary files, build results, and
## files generated by popular Visual Studio add-ons.
##
## Get latest from https://github.com/github/gitignore/blob/master/VisualStudio.gitignore
# User-specific files
*.rsuser
*.suo
*.user
*.userosscache
*.sln.docstates
# User-specific files (MonoDevelop/Xamarin Studio)
*.userprefs
# Mono auto generated files
mono_crash.*
# Build results
[Dd]ebug/
[Dd]ebugPublic/
[Rr]elease/
[Rr]eleases/
x64/
x86/
[Aa][Rr][Mm]/
[Aa][Rr][Mm]64/
bld/
[Bb]in/
[Oo]bj/
[Ll]og/
# Visual Studio 2015/2017 cache/options directory
.vs/
# Uncomment if you have tasks that create the project's static files in wwwroot
#wwwroot/
# Visual Studio 2017 auto generated files
Generated\ Files/
# MSTest test Results
[Tt]est[Rr]esult*/
[Bb]uild[Ll]og.*
# NUNIT
*.VisualState.xml
TestResult.xml
# Build Results of an ATL Project
[Dd]ebugPS/
[Rr]eleasePS/
dlldata.c
# Benchmark Results
BenchmarkDotNet.Artifacts/
# .NET Core
project.lock.json
project.fragment.lock.json
artifacts/
# StyleCop
StyleCopReport.xml
# Files built by Visual Studio
*_i.c
*_p.c
*_h.h
*.ilk
*.meta
*.obj
*.iobj
*.pch
*.pdb
*.ipdb
*.pgc
*.pgd
*.rsp
*.sbr
*.tlb
*.tli
*.tlh
*.tmp
*.tmp_proj
*_wpftmp.csproj
*.log
*.vspscc
*.vssscc
.builds
*.pidb
*.svclog
*.scc
# Chutzpah Test files
_Chutzpah*
# Visual C++ cache files
ipch/
*.aps
*.ncb
*.opendb
*.opensdf
*.sdf
*.cachefile
*.VC.db
*.VC.VC.opendb
# Visual Studio profiler
*.psess
*.vsp
*.vspx
*.sap
# Visual Studio Trace Files
*.e2e
# TFS 2012 Local Workspace
$tf/
# Guidance Automation Toolkit
*.gpState
# ReSharper is a .NET coding add-in
_ReSharper*/
*.[Rr]e[Ss]harper
*.DotSettings.user
# JustCode is a .NET coding add-in
.JustCode
# TeamCity is a build add-in
_TeamCity*
# DotCover is a Code Coverage Tool
*.dotCover
# AxoCover is a Code Coverage Tool
.axoCover/*
!.axoCover/settings.json
# Visual Studio code coverage results
*.coverage
*.coveragexml
# NCrunch
_NCrunch_*
.*crunch*.local.xml
nCrunchTemp_*
# MightyMoose
*.mm.*
AutoTest.Net/
# Web workbench (sass)
.sass-cache/
# Installshield output folder
[Ee]xpress/
# DocProject is a documentation generator add-in
DocProject/buildhelp/
DocProject/Help/*.HxT
DocProject/Help/*.HxC
DocProject/Help/*.hhc
DocProject/Help/*.hhk
DocProject/Help/*.hhp
DocProject/Help/Html2
DocProject/Help/html
# Click-Once directory
publish/
# Publish Web Output
*.[Pp]ublish.xml
*.azurePubxml
# Note: Comment the next line if you want to checkin your web deploy settings,
# but database connection strings (with potential passwords) will be unencrypted
*.pubxml
*.publishproj
# Microsoft Azure Web App publish settings. Comment the next line if you want to
# checkin your Azure Web App publish settings, but sensitive information contained
# in these scripts will be unencrypted
PublishScripts/
# NuGet Packages
*.nupkg
# The packages folder can be ignored because of Package Restore
**/[Pp]ackages/*
# except build/, which is used as an MSBuild target.
!**/[Pp]ackages/build/
# Uncomment if necessary however generally it will be regenerated when needed
#!**/[Pp]ackages/repositories.config
# NuGet v3's project.json files produces more ignorable files
*.nuget.props
*.nuget.targets
# Microsoft Azure Build Output
csx/
*.build.csdef
# Microsoft Azure Emulator
ecf/
rcf/
# Windows Store app package directories and files
AppPackages/
BundleArtifacts/
Package.StoreAssociation.xml
_pkginfo.txt
*.appx
*.appxbundle
*.appxupload
# Visual Studio cache files
# files ending in .cache can be ignored
*.[Cc]ache
# but keep track of directories ending in .cache
!?*.[Cc]ache/
# Others
ClientBin/
~$*
*~
*.dbmdl
*.dbproj.schemaview
*.jfm
*.pfx
*.publishsettings
orleans.codegen.cs
# Including strong name files can present a security risk
# (https://github.com/github/gitignore/pull/2483#issue-259490424)
#*.snk
# Since there are multiple workflows, uncomment next line to ignore bower_components
# (https://github.com/github/gitignore/pull/1529#issuecomment-104372622)
#bower_components/
# RIA/Silverlight projects
Generated_Code/
# Backup & report files from converting an old project file
# to a newer Visual Studio version. Backup files are not needed,
# because we have git ;-)
_UpgradeReport_Files/
Backup*/
UpgradeLog*.XML
UpgradeLog*.htm
ServiceFabricBackup/
*.rptproj.bak
# SQL Server files
*.mdf
*.ldf
*.ndf
# Business Intelligence projects
*.rdl.data
*.bim.layout
*.bim_*.settings
*.rptproj.rsuser
*- Backup*.rdl
# Microsoft Fakes
FakesAssemblies/
# GhostDoc plugin setting file
*.GhostDoc.xml
# Node.js Tools for Visual Studio
.ntvs_analysis.dat
node_modules/
# Visual Studio 6 build log
*.plg
# Visual Studio 6 workspace options file
*.opt
# Visual Studio 6 auto-generated workspace file (contains which files were open etc.)
*.vbw
# Visual Studio LightSwitch build output
**/*.HTMLClient/GeneratedArtifacts
**/*.DesktopClient/GeneratedArtifacts
**/*.DesktopClient/ModelManifest.xml
**/*.Server/GeneratedArtifacts
**/*.Server/ModelManifest.xml
_Pvt_Extensions
# Paket dependency manager
.paket/paket.exe
paket-files/
# FAKE - F# Make
.fake/
# CodeRush personal settings
.cr/personal
# Python Tools for Visual Studio (PTVS)
__pycache__/
*.pyc
# Cake - Uncomment if you are using it
# tools/**
# !tools/packages.config
# Tabs Studio
*.tss
# Telerik's JustMock configuration file
*.jmconfig
# BizTalk build output
*.btp.cs
*.btm.cs
*.odx.cs
*.xsd.cs
# OpenCover UI analysis results
OpenCover/
# Azure Stream Analytics local run output
ASALocalRun/
# MSBuild Binary and Structured Log
*.binlog
# NVidia Nsight GPU debugger configuration file
*.nvuser
# MFractors (Xamarin productivity tool) working folder
.mfractor/
# Local History for Visual Studio
.localhistory/
# BeatPulse healthcheck temp database
healthchecksdb
# Backup folder for Package Reference Convert tool in Visual Studio 2017
MigrationBackup/
##
## Visual studio for Mac
##
# globs
Makefile.in
*.userprefs
*.usertasks
config.make
config.status
aclocal.m4
install-sh
autom4te.cache/
*.tar.gz
tarballs/
test-results/
# Mac bundle stuff
*.dmg
*.app
# content below from: https://github.com/github/gitignore/blob/master/Global/macOS.gitignore
# General
.DS_Store
.AppleDouble
.LSOverride
# Icon must end with two \r
Icon
# Thumbnails
._*
# Files that might appear in the root of a volume
.DocumentRevisions-V100
.fseventsd
.Spotlight-V100
.TemporaryItems
.Trashes
.VolumeIcon.icns
.com.apple.timemachine.donotpresent
# Directories potentially created on remote AFP share
.AppleDB
.AppleDesktop
Network Trash Folder
Temporary Items
.apdisk
# content below from: https://github.com/github/gitignore/blob/master/Global/Windows.gitignore
# Windows thumbnail cache files
Thumbs.db
ehthumbs.db
ehthumbs_vista.db
# Dump file
*.stackdump
# Folder config file
[Dd]esktop.ini
# Recycle Bin used on file shares
$RECYCLE.BIN/
# Windows Installer files
*.cab
*.msi
*.msix
*.msm
*.msp
# Windows shortcuts
*.lnk
# JetBrains Rider
.idea/
*.sln.iml
##
## Visual Studio Code
##
.vscode/*
!.vscode/settings.json
!.vscode/tasks.json
!.vscode/launch.json
!.vscode/extensions.json
# Test configuration
/src/Octonica.ClickHouseClient.Tests/clickHouse.dbconfig
# Benchmark configuration
/src/Octonica.ClickHouseClient.Benchmarks/clickHouse.dbconfig
================================================
FILE: CHANGELOG.md
================================================
### Octonica.ClickHouseClient Next Version, Unscheduled
#### New Feature
* Add method `ClickHouseDataReader.ConfigureColumnReader` which sets a value cast callback function for the column.
The callback function is invoked whenever the reader reads a non-null value from the column. This feature could be useful in
cases when ClcikHouseClient doesn't have a built-in type conversion rule, for expample, `double -> decimal`, `Guid -> string` or `uint -> int`.
#### Improvement
* Add method `ClickHouseParameterCollection.AddRange` receiveng any enumerable collection of `ClickHouseParameter`.
### Octonica.ClickHouseClient v2.2.11, 2023-01-11
#### Bug Fix
* Fix null reference exception when the garbage collector calls the finalizer for `ClickHouseConnection` ([#70](https://github.com/Octonica/ClickHouseClient/issues/70)).
### Octonica.ClickHouseClient v2.2.10, 2022-12-30
#### New Feature
* Add support for the type `Bool` ([#56](https://github.com/Octonica/ClickHouseClient/issues/56)).
#### Bug Fix
* Return the correct non-generic enumerator for `ClickHouseParameterCollection` (PR [#65](https://github.com/Octonica/ClickHouseClient/pull/65)).
#### Improvement
* Remove arguments with default values from constructors of `ClickHouseConnection`. It makes possible to call the constructor `ClickHouseConnection(sting)` using reflection
([#54](https://github.com/Octonica/ClickHouseClient/issues/54)).
### Octonica.ClickHouseClient v2.2.9, 2022-04-27
#### New Feature
* New mode of passing parameters to a query - `Interpolate`. In this mode values are interpolated into the query text as constant literals.
Parameter mode can be set for a connection (the property `ParametersMode` in the connection string), for a command (the property `ClickHouseCommand.ParametersMode`) or
for a single parameter (`ClickHouseParameter.ParameterMode`)
([#49](https://github.com/Octonica/ClickHouseClient/issues/49), PR [#42](https://github.com/Octonica/ClickHouseClient/pull/42)).
#### Improvement
* Set `DateTimeKind.Unspecified` when cast a value of ClickHouse types `Date` and `Date32` to the .NET type `DateTime` (PR [#45](https://github.com/Octonica/ClickHouseClient/pull/45)).
### Octonica.ClickHouseClient v2.2.8, 2022-01-09
#### Bug Fix
* Fix getting a time zone from IANA code. This fix is only applicable to the .NET 6 version of ClickHouseClient running on Windows ([#40](https://github.com/Octonica/ClickHouseClient/issues/40)).
#### Improvement
* Make possible to open a connection to the server with an unrecognized time zone. The `TimeZoneNotFoundException` may be thrown later when reading
the column of type `DateTime` or `DateTime64` ([#40](https://github.com/Octonica/ClickHouseClient/issues/40)).
#### Miscellaneous
* Default protocol revision is set to 54452. This change was made because the minimal protocol revison with profile events was updated in the ClickHouse v21.12.
### Octonica.ClickHouseClient v2.2.7, 2021-12-04
#### New Feature
* .NET 6.0 support ([#33](https://github.com/Octonica/ClickHouseClient/issues/33)):
* New API for time zones. Remove dependency from the package TimeZoneConverter;
* Change mapping of the ClickHouse type `Date` from `DateTime` to `DateOnly`. This affects the behavior of methods `ClickHouseDataReader.GetValue` and `ClickHouseDataReader.GetValues`;
* Add the method `ClickHouseDataReader.GetDate` for reading values of types `Date` and `Date32`.
* Add methods to the `ClickHouseDataReader` for reading values of well-known types ([#38](https://github.com/Octonica/ClickHouseClient/issues/38)):
* `GetBigInteger`;
* `GetIPAddress`;
* `GetSByte`;
* `GetUInt16`;
* `GetUInt32`;
* `GetUInt64`.
* Add support for the type `Date32` ([#36](https://github.com/Octonica/ClickHouseClient/issues/36)).
* Add support for profile events. Profile events are disabled by default. To enable it set the value of the property `ClickHouseCommand.IgnoreProfileEvents` to `false`.
Please note that the method `ClickHouseDataReader.NextResult` (or `NextResultAsync`) should be called for switching between regular data and profile events.
#### Bug Fix
* Fix reading empty values of the type `LowCardinality(String)` ([#37](https://github.com/Octonica/ClickHouseClient/issues/37)).
#### Miscellaneous
* Default protocol revision is set to 54450.
### Octonica.ClickHouseClient release v2.1.2, 2021-11-07
#### New Feature
* Add support for Transport Layer Security (TLS) connection ([#35](https://github.com/Octonica/ClickHouseClient/issues/35)).
### Octonica.ClickHouseClient release v2.1.1, 2021-09-16
#### Backward Incompatible Change
* Classes from the namespace `Octonica.ClickHouseClient` that are now sealed and therefore can't be inherited:
* `ClickHouseColumnWriter`;
* `ClickHouseCommand`;
* `ClickHouseConnection`;
* `ClickHouseConnectionSettings`;
* `ClickHouseDataReader`;
* `ClickHouseParameter`;
* `ClickHouseParameterCollection`;
* `ClickHouseServerInfo`;
* `ClickHouseTableColumnCollection`;
* `ClickHouseTableProvider`;
* `ClickHouseTableProviderCollection`.
* Classes, enums and interfaces from the namespace `Octonica.ClickHouseClient.Protocol` that are no longer public:
* `BlockFieldCodes`;
* `CompressionAlgorithm`;
* `IClickHouseTableWriter`;
* `NullableObjTableColumn<TObj>`.
* The class `ClickHouseColumnSettings` was moved from the namespace `Octonica.ClickHouseClient.Protocol` to the namespace `Octonica.ClickHouseClient`.
* The class `Revisions` from the namespace `Octonica.ClickHouseClient.Protocol` was renamed to `ClickHouseProtocolRevisions`.
#### Improvement
* Add XML documentation comments to the NuGet package.
#### Bug Fix
* Fix reading and writing values of the type `Array(LowCardinality(T))` ([#34](https://github.com/Octonica/ClickHouseClient/issues/34)).
* Fix error handling for `ClickHouseColumnWriter`.
### Octonica.ClickHouseClient release v1.3.1, 2021-07-13
#### New Feature
* Values of the type `FixedString` can be converted to the type `char[]`.
* Values of the type `String` can be converted to types `char[]` and `byte[]`.
#### Miscellaneous
* Basic interfaces of the column reader were modified. Despite these interfaces are public,
they are supposedly used only by an internal part of ClickHouseClient.
### Octonica.ClickHouseClient release v1.2.1, 2021-06-25
### New Feature
* Add support for user-defined tables in queries. New property `ClickHouseCommand.TableProviders` provides access to a collection of user-defined
tables associated with the command. See the section *'Table-valued parameters'* of [Parameters](docs/Parameters.md) for details ([#24](https://github.com/Octonica/ClickHouseClient/issues/24)).
* Add property `ClickHouseColumnWriter.MaxBlockSize`. This property allows to set the maximal number of rows which can be sent to the server as
a single block of data. If an input table contains more rows than `MaxBlockSize` it will be sent to the server by parts ([#26](https://github.com/Octonica/ClickHouseClient/issues/26)).
* Add support for the experimental type `Map(key, value)` ([#31](https://github.com/Octonica/ClickHouseClient/issues/31)).
* Add support for long integer types `Int128`, `UInt128`, `Int256` and `UInt256` ([#27](https://github.com/Octonica/ClickHouseClient/issues/27)).
#### Improvement
* Improve performance of reading and writing values of primitive types.
* Improve connection state management and error handling.
### Octonica.ClickHouseClient release v1.1.13, 2021-05-29
#### Bug Fix
* Fix conversion from `System.Guid` to `UUID`. This bug affected `ClickHouseColumnWriter`.
It caused writing of corrupted values to a column of type `UUID` ([#29](https://github.com/Octonica/ClickHouseClient/issues/29)).
#### New Feature
* Add method `ClickHouseConnection.TryPing`. This method allows to send 'Ping' message and wait for response from the server.
#### Improvement
* Add cast from `UInt8` to `bool`. `ClickHouseDataReader.GetBoolean` no longer throws an exception for values of type `UInt8`.
### Octonica.ClickHouseClient release v1.1.12, 2021-05-19
#### Backward Incompatible Change
* `ClickHouseDataReader.GetField` and `ClickHouseColumnWriter.GetField` now return `typeof(T)` instead of `typeof(Nullable<T>)` for nullable fields.
It is possible to get original type of a column from field's type info: `ClickClickHouseDataReader.GetFieldTypeInfo(int ordinal).GetFieldType()`.
* Stricter column type check. `ClickHouseColumnWriter` throws an exception when a type of a column is ambiguous
(for example, a column's type implements both `IReadOnlyList<int>` and `IReadOnlyList<int?>`).
#### New Feature
* Add support for named tuples.
* Add a way to explicitly set a type of a column. The type could be defined in `ClickHouseColumnSettings`. `ClickHouseDataReader` will try to convert
a column's value to this type. `ClickHouseColumnWriter` will expect a column to be a collection of items of this type.
* Add support for `IReadOnlyList<object>`, `IList<object>`, `IEnumerable<object>` and `IAsyncEnumerable<object>` to `ClickHouseColumnWriter` ([#21](https://github.com/Octonica/ClickHouseClient/issues/21)).
#### Bug Fix
* Add recognition of escape sequences in enum's item names.
### Octonica.ClickHouseClient release v1.1.9, 2021-05-07
#### New Feature
* Parameters in the format `@paramName` are supported in the text of a query ([#19](https://github.com/Octonica/ClickHouseClient/issues/19)).
### Octonica.ClickHouseClient release v1.1.8, 2021-04-25
#### New Feature
* `ClickHouseCommand.ExecuteDbDataReader` supports non-default command behavior ([#18](https://github.com/Octonica/ClickHouseClient/issues/18)).
* Added method `GetTypeArgument` to the interface `IClickHouseTypeInfo`. This method allows to get additional arguments of the type (scale, precision, timezone, size).
### Octonica.ClickHouseClient release v1.1.7, 2021-03-15
#### Bug Fix
* Fixed error handling for `ClickHouseConnection.Open`. The socket was not properly disposed when error occurred during opening a connection.
### Octonica.ClickHouseClient release v1.1.6, 2021-03-08
#### Backward Incompatible Change
* ClickHouseParameter can't be added to several parameter collections. Use the method `ClickHouseParameter.Clone` to create a parameter's copy which doesn't belong to the collection.
#### New Feature
* Octonica.ClickHouseClient for .NET 5.0 was added to NuGet package.
* Added ClickHouseDbProviderFactory which implements DbProviderFactory.
* `ReadOnlyMemory<char>` or `Memory<char>` can be used instead of `string` when writing values to ClickHouse.
* `ReadOnlyMemory<T>` or `Memory<T>` can be used instead of `T[]` (array of `T`) when writing values to ClickHouse.
#### Bug Fix
* Fixed possible race condition when disposing a connection from different threads ([#16](https://github.com/Octonica/ClickHouseClient/issues/16)).
#### Improvement
* Improved implementation of various classes from `System.Data.Common` namespace, such as `DbConnection`, `DbCommand` and `DbParameter`.
### Octonica.ClickHouseClient release v1.0.17, 2020-12-10
#### Bug Fix
* Fixed execution of queries which affect large (greater than 2^31) number of rows ([#15](https://github.com/Octonica/ClickHouseClient/issues/15)).
* Fixed comparison of parameter's names in ClickHouseParameterCollection.
#### Improvement
* Added public method `ClickHouseParameter.IsValidParameterName` which allows to check if the string can be used as the name of a parameter.
### Octonica.ClickHouseClient release v1.0.14, 2020-12-02
#### Bug Fix
* The driver was incompatible with ClickHouse v2.10 and higher.
* Fixed writing columns from a source which contains more rows than `rowCount`.
* Fixed writing columns from a source which implements `IList<T>` but doesn't implement `IReadOnlyList<T>`.
### Octonica.ClickHouseClient release v1.0.13, 2020-11-11
#### Backward Incompatible Change
* The default name of the client changed from `Octonica.ClickHouse` to `Octonica.ClickHouseClient`.
#### New Feature
* Added type `DateTime64`.
* Implemented methods `NextResult` and `NextResultAsync` in `ClickHouseDataReader`. These methods can be used to read totals and extremes ([#11](https://github.com/Octonica/ClickHouseClient/issues/11)).
* Added `Extremes` property to `ClickHouseCommand`. It allows to toggle `extremes` setting for the query.
* Added `TimeZone` property to `ClickHouseParameter`. It allows to specify the timezone for datetime types.
* Array can be used as the value of command parameter. Added properties `IsArray` and `ArrayRank` to `ClickHouseParameter` ([#14](https://github.com/Octonica/ClickHouseClient/issues/14)).
#### Bug Fix
* The type `UInt64` was mapped to the type `UInt32` in the command parameter.
#### Improvement
* Detection of attempts to connect to ClickHouse server with HTTP protocol ([#10](https://github.com/Octonica/ClickHouseClient/issues/10)).
* `ReadWriteTimeout` is respected in async network operations if `cancellationToken` is not defined (i.e. `CanellationToken.None`).
#### Miscellaneous
* Default protocol revision is set to 54441.
================================================
FILE: LICENSE
================================================
Copyright 2019-2026 Octonica
Apache License
Version 2.0, January 2004
http://www.apache.org/licenses/
TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
1. Definitions.
"License" shall mean the terms and conditions for use, reproduction,
and distribution as defined by Sections 1 through 9 of this document.
"Licensor" shall mean the copyright owner or entity authorized by
the copyright owner that is granting the License.
"Legal Entity" shall mean the union of the acting entity and all
other entities that control, are controlled by, or are under common
control with that entity. For the purposes of this definition,
"control" means (i) the power, direct or indirect, to cause the
direction or management of such entity, whether by contract or
otherwise, or (ii) ownership of fifty percent (50%) or more of the
outstanding shares, or (iii) beneficial ownership of such entity.
"You" (or "Your") shall mean an individual or Legal Entity
exercising permissions granted by this License.
"Source" form shall mean the preferred form for making modifications,
including but not limited to software source code, documentation
source, and configuration files.
"Object" form shall mean any form resulting from mechanical
transformation or translation of a Source form, including but
not limited to compiled object code, generated documentation,
and conversions to other media types.
"Work" shall mean the work of authorship, whether in Source or
Object form, made available under the License, as indicated by a
copyright notice that is included in or attached to the work
(an example is provided in the Appendix below).
"Derivative Works" shall mean any work, whether in Source or Object
form, that is based on (or derived from) the Work and for which the
editorial revisions, annotations, elaborations, or other modifications
represent, as a whole, an original work of authorship. For the purposes
of this License, Derivative Works shall not include works that remain
separable from, or merely link (or bind by name) to the interfaces of,
the Work and Derivative Works thereof.
"Contribution" shall mean any work of authorship, including
the original version of the Work and any modifications or additions
to that Work or Derivative Works thereof, that is intentionally
submitted to Licensor for inclusion in the Work by the copyright owner
or by an individual or Legal Entity authorized to submit on behalf of
the copyright owner. For the purposes of this definition, "submitted"
means any form of electronic, verbal, or written communication sent
to the Licensor or its representatives, including but not limited to
communication on electronic mailing lists, source code control systems,
and issue tracking systems that are managed by, or on behalf of, the
Licensor for the purpose of discussing and improving the Work, but
excluding communication that is conspicuously marked or otherwise
designated in writing by the copyright owner as "Not a Contribution."
"Contributor" shall mean Licensor and any individual or Legal Entity
on behalf of whom a Contribution has been received by Licensor and
subsequently incorporated within the Work.
2. Grant of Copyright License. Subject to the terms and conditions of
this License, each Contributor hereby grants to You a perpetual,
worldwide, non-exclusive, no-charge, royalty-free, irrevocable
copyright license to reproduce, prepare Derivative Works of,
publicly display, publicly perform, sublicense, and distribute the
Work and such Derivative Works in Source or Object form.
3. Grant of Patent License. Subject to the terms and conditions of
this License, each Contributor hereby grants to You a perpetual,
worldwide, non-exclusive, no-charge, royalty-free, irrevocable
(except as stated in this section) patent license to make, have made,
use, offer to sell, sell, import, and otherwise transfer the Work,
where such license applies only to those patent claims licensable
by such Contributor that are necessarily infringed by their
Contribution(s) alone or by combination of their Contribution(s)
with the Work to which such Contribution(s) was submitted. If You
institute patent litigation against any entity (including a
cross-claim or counterclaim in a lawsuit) alleging that the Work
or a Contribution incorporated within the Work constitutes direct
or contributory patent infringement, then any patent licenses
granted to You under this License for that Work shall terminate
as of the date such litigation is filed.
4. Redistribution. You may reproduce and distribute copies of the
Work or Derivative Works thereof in any medium, with or without
modifications, and in Source or Object form, provided that You
meet the following conditions:
(a) You must give any other recipients of the Work or
Derivative Works a copy of this License; and
(b) You must cause any modified files to carry prominent notices
stating that You changed the files; and
(c) You must retain, in the Source form of any Derivative Works
that You distribute, all copyright, patent, trademark, and
attribution notices from the Source form of the Work,
excluding those notices that do not pertain to any part of
the Derivative Works; and
(d) If the Work includes a "NOTICE" text file as part of its
distribution, then any Derivative Works that You distribute must
include a readable copy of the attribution notices contained
within such NOTICE file, excluding those notices that do not
pertain to any part of the Derivative Works, in at least one
of the following places: within a NOTICE text file distributed
as part of the Derivative Works; within the Source form or
documentation, if provided along with the Derivative Works; or,
within a display generated by the Derivative Works, if and
wherever such third-party notices normally appear. The contents
of the NOTICE file are for informational purposes only and
do not modify the License. You may add Your own attribution
notices within Derivative Works that You distribute, alongside
or as an addendum to the NOTICE text from the Work, provided
that such additional attribution notices cannot be construed
as modifying the License.
You may add Your own copyright statement to Your modifications and
may provide additional or different license terms and conditions
for use, reproduction, or distribution of Your modifications, or
for any such Derivative Works as a whole, provided Your use,
reproduction, and distribution of the Work otherwise complies with
the conditions stated in this License.
5. Submission of Contributions. Unless You explicitly state otherwise,
any Contribution intentionally submitted for inclusion in the Work
by You to the Licensor shall be under the terms and conditions of
this License, without any additional terms or conditions.
Notwithstanding the above, nothing herein shall supersede or modify
the terms of any separate license agreement you may have executed
with Licensor regarding such Contributions.
6. Trademarks. This License does not grant permission to use the trade
names, trademarks, service marks, or product names of the Licensor,
except as required for reasonable and customary use in describing the
origin of the Work and reproducing the content of the NOTICE file.
7. Disclaimer of Warranty. Unless required by applicable law or
agreed to in writing, Licensor provides the Work (and each
Contributor provides its Contributions) on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
implied, including, without limitation, any warranties or conditions
of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
PARTICULAR PURPOSE. You are solely responsible for determining the
appropriateness of using or redistributing the Work and assume any
risks associated with Your exercise of permissions under this License.
8. Limitation of Liability. In no event and under no legal theory,
whether in tort (including negligence), contract, or otherwise,
unless required by applicable law (such as deliberate and grossly
negligent acts) or agreed to in writing, shall any Contributor be
liable to You for damages, including any direct, indirect, special,
incidental, or consequential damages of any character arising as a
result of this License or out of the use or inability to use the
Work (including but not limited to damages for loss of goodwill,
work stoppage, computer failure or malfunction, or any and all
other commercial damages or losses), even if such Contributor
has been advised of the possibility of such damages.
9. Accepting Warranty or Additional Liability. While redistributing
the Work or Derivative Works thereof, You may choose to offer,
and charge a fee for, acceptance of support, warranty, indemnity,
or other liability obligations and/or rights consistent with this
License. However, in accepting such obligations, You may act only
on Your own behalf and on Your sole responsibility, not on behalf
of any other Contributor, and only if You agree to indemnify,
defend, and hold each Contributor harmless for any liability
incurred by, or claims asserted against, such Contributor by reason
of your accepting any such warranty or additional liability.
END OF TERMS AND CONDITIONS
APPENDIX: How to apply the Apache License to your work.
To apply the Apache License to your work, attach the following
boilerplate notice, with the fields enclosed by brackets "[]"
replaced with your own identifying information. (Don't include
the brackets!) The text should be enclosed in the appropriate
comment syntax for the file format. We also recommend that a
file or class name and description of purpose be included on the
same "printed page" as the copyright notice for easier
identification within third-party archives.
Copyright 2026 Octonica
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
================================================
FILE: README.md
================================================
ClickHouse .NET Core driver
===============
This is an implementation of .NET Core driver for ClickHouse in a form of ADO.NET DbProvider API. This driver supports all ADO.NET features (with some exclusions like transaction support).
### Features
* supports binary protocol
* compression (send and recieve)
* timezones
* most clickhouse [column types](docs/TypeMapping.md) are supported ([aggregating ones](https://clickhouse.tech/docs/en/sql_reference/data_types/aggregatefunction/) are under development)
* full support for .net async ADO.NET API
* no unsafe code
* ~~tested~~- used in production
* c# named tuple and record support
* [Dapper](https://dapperlib.github.io/Dapper/) support (example in [#19](https://github.com/Octonica/ClickHouseClient/issues/19))
* [Linq To DB](https://github.com/linq2db/linq2db) support
### Usage
Install from [NuGet](https://www.nuget.org/packages/Octonica.ClickHouseClient/):
```
dotnet add package Octonica.ClickHouseClient
```
ConnectionString syntax:
`Host=<host>;Port=<port>;Database=<db>;Password=<pass>`, e.g. `"Host=127.0.0.1;Password=P@ssw0rd; Database=db` additionally, if you want to build a connection string via code you can use `ClickHouseConnectionStringBuilder`.
Entry point for API is ADO .NET DbConnection Class: `Octonica.ClickHouse.ClickHouseConnection`.
### Extended API
In order to provide non-ADO.NET complaint data manipulation functionality, proprietary [ClickHouseColumnWriter](docs/ClickHouseColumnWriter.md) API exists.
Entry point for API is `ClickHouseConnection.CreateColumnWriter()` method.
#### Simple SELECT async verison
```csharp
var sb = new ClickHouseConnectionStringBuilder();
sb.Host = "127.0.0.1";
using var conn = new ClickHouseConnection(sb);
await conn.OpenAsync();
var currentUser = await conn.CreateCommand("select currentUser()").ExecuteScalarAsync();
```
#### Insert data with parameters
```csharp
var sb = new ClickHouseConnectionStringBuilder();
sb.Host = "127.0.0.1";
using var conn = new ClickHouseConnection(sb);
conn.Open();
using var cmd = conn.CreateCommand("INSERT INTO table_you_just_created SELECT {id}, {dt}");
cmd.Parameters.AddWithValue("id", Guid.NewGuid());
cmd.Parameters.AddWithValue("dt", DateTime.Now, System.Data.DbType.DateTime);
var _ = cmd.ExecuteNonQuery();
```
For more information see [Parameters](docs/Parameters.md).
#### Bulk insert
```csharp
using var conn = new ClickHouseConnection("Host=127.0.0.1");
conn.Open();
using var cmd = conn.CreateCommand("CREATE TABLE IF NOT EXISTS table_with_two_fields(id Int32, name String) engine Memory");
await cmd.ExecuteNonQueryAsync();
//generate values
List<int> ids = Enumerable.Range(1, 10_000).ToList();
List<string> names = ids.Select(i => $"Name #{i}").ToList();
//insert data
await using (var writer = await conn.CreateColumnWriterAsync("insert into table_with_two_fields(id, name) values", default))
{
await writer.WriteTableAsync(new object[] { ids, names }, ids.Count, default);
}
```
### Build requirements
In order to build the driver you need to have .NET SDK 5.0 or higher.
================================================
FILE: docs/ClickHouseColumnWriter.md
================================================
# ClickHouseColumnWriter
`ClickHouseColumnWriter` is a class dedicated for writing arbitrary large amount of rows to a table.
It writes tables in a columnar layout. It means that the table consists of several columns and
each column contains a list of values (cells) of a particular type. All columns of the table must contain
the same number of cells.
To create a writer call the method `ClickHouseConnection.CreateColumnWriter` (or `ClickHouseConnection.CreateColumnWriterAsync`).
```C#
using var connection = ClickHouseConnection(connectionStr);
connection.Open();
using var writer = connection.CreateColumnWriter("INSERT INTO some_table VALUES");
```
Please, note that the `INSERT` query for the writer must end with `VALUES` keyword, but without actual list of values.
Some methods of `ClickHouseColumnWriter` are similar to methods of `ClickHouseDataReader`: `GetName`, `GetOrdinal`, `GetFieldType`,
`ConfigureColumn` and other methods for manipulating column metadata.
Here is the method for writing tables:
```C#
void WriteTable(IReadOnlyList<object?> columns, int rowCount)
```
A column could be of any type which implements one of interfaces:
* `IReadOnlyList<T>`;
* `IList<T>`;
* `IEnumerable<T>`;
* `IAsyncEnumerable<T>` (supported only by `WriteTableAsync`);
* `IEnumerable`.
The number of columns must be equal to the number of columns in the initial `INSERT` query. Columns may have different number of rows,
but not less than `rowCount`. Columns must be passed in the order defined by the query.
There is an overload of `WriteTable` which distinguishes columns by their names:
```C#
void WriteTable(IReadOnlyDictionary<string, object?> columns, int rowCount)
```
## Examples
Assume there is a table `some_table`.
```C#
using var connection = new ClickHouseConnection(connectionStr);
connection.Open();
var cmd = connection.CreateCommand("CREATE TABLE some_table(id Int32, str Nullable(String), dt DateTime, val Decimal64(4)) ENGINE = Memory");
cmd.ExecuteNonQuery();
```
### Write ordered columns
```C#
var id = new List<Guid>();
var str = new List<string?>();
var dt = new List<DateTime>();
var val = new List<decimal>();
/*
* Fill lists id, str, dt and val with actual values
*/
await using var connection = new ClickHouseConnection(connectionStr);
await connection.OpenAsync();
await using var writer = connection.CreateColumnWriter("INSERT INTO some_table VALUES");
var columns = new object[writer.FieldCount];
columns[writer.GetOrdinal("id")] = id;
columns[writer.GetOrdinal("str")] = str;
columns[writer.GetOrdinal("dt")] = dt;
columns[writer.GetOrdinal("val")] = val;
var rowCount = id.Count;
await writer.WriteTableAsync(columns, rowCount, CancellationToken.None);
```
### Write named columns
```C#
var id = new List<Guid>();
var dt = new List<DateTime>();
var val = new List<decimal>();
/*
* Fill lists id, dt and val with actual values
*/
await using var connection = new ClickHouseConnection(connectionStr);
await connection.OpenAsync();
await using var writer = connection.CreateColumnWriter("INSERT INTO some_table(id, dt, val) VALUES");
var columns = new Dictionary<string, object?>
{
["id"] = id,
["dt"] = dt,
["val"] = val
};
var rowCount = id.Count;
await writer.WriteTableAsync(columns, rowCount, CancellationToken.None);
```
================================================
FILE: docs/Parameters.md
================================================
# Parameters
ClickHouseClient's implementation of parameters is compliant with ADO.NET. API for working with parameters intended to be familiar to users of
other ADO.NET drivers.
Each command (`Octonica.ClickHouseClient.ClickHouseCommand`) contains a collection of parameters. This collection can be acquired with the
property `Parameters`. Parameters from this collection can be referenced in a query.
## Parameter format
As specified in [Queries with Parameters](https://clickhouse.tech/docs/en/interfaces/cli/#cli-queries-with-parameters) the default format
of the parameter is `{<name>:<data type>}`. However, the type can be derived from the parameter's settings, which allows to omit `:<data type>`
part and declare parameter just as `{<name>}`.
ClickHouseClient also supports parameters in MSSQL-like format: `@<name>`.
Here is an example demonstrating different namestyles of parameters:
```C#
using var connection = new ClickHouseConnection(connectionStr);
connection.Open();
var cmd = connection.CreateCommand("SELECT number/{value:Decimal64(2)} FROM numbers(100000) WHERE number >= @min AND number <= {max}");
cmd.Parameters.AddWithValue("value", 100);
cmd.Parameters.AddWithValue("{min}", 1000);
cmd.Parameters.AddWithValue("@max", 2000);
using var reader = cmd.ExecuteReader();
while(reader.Read())
{
// Reading the data
}
```
## Parameter settings
The settings of the parameter usually can be detected based on the type of the parameter's value. It is possible to override auto-detected settings
in cases when auto-detection fails or when the required type of the parameter doesn't match to the type of the parameter's value. When settings are
overridden ClickHouseClient will try to convert parameter's value to the requested type.
There are settings inherited from `System.Data.Common.DbParameter`:
1. `DbType`. The type of the parameter. `System.Data.DbType` is a subset of `Octonica.ClickHouseClient.ClickHouseDbType`. For any value of the property
`ClickHouseDbType` which can't be mapped to the type `System.Data.DbType` this property returns `DbType.Object`;
2. `IsNullable`. Indicates whether the parameter accept `NULL`;
3. `Precision`. Defines the precision for `Decimal` or `DateTime64`;
4. `Scale`. Defines the scale for `Decimal`;
5. `Size`. Defines the size for `FixedString`.
And there are additional settings supported by `Octonica.ClickHouseClient.ClickHouseParameter`:
1. `ArrayRank`. The number of dimensions in the array. Zero for non-arrays;
2. `ClickHouseDbType`. The type of the parameter;
3. `IsArray`. Indicates whether the parameter is an array, i.e. `ArrayRank > 0`;
4. `StringEncoding`. Defines the encoding which will be used for strings;
5. `TimeZone`. Defines the timezone for `DateTime` or `DateTime64`.
## Table-valued parameters
To be fair, a parameter can't be a table. However, ClickHouse allows to pass arbitrary tables with a query. These tables can be referenced in the query
without special syntax.
The tables and parameters are stored separately in `Octonica.ClickHouseClient.ClickHouseCommand`. The collection of tables can be acquired with the property
`TableProviders` of the command.
The basic interface for client-defined table is `Octonica.ClickHouseClient.IClickHouseTableProvider`. A class implementing this interface should provide
a table in a columnar format. There is a default implementation of this interface: `Octonica.ClickHouseClient.ClickHouseTableProvider`. This class allows
to pass a table in a way similar to [ClickHouseColumnWriter](ClickHouseColumnWriter.md).
Here is a simple example demonstrating how to pass a client-defined table to a query:
```C#
using var connection = new ClickHouseConnection(connectionStr);
connection.Open();
var cmd = connection.CreateCommand("SELECT ptable.id, ptable.user, ptable.ip FROM ptable");
var users = new[] {"user1", "user2", "admin1", "admin2"};
var ips = new[] {"1.1.1.1", "2.2.2.2", "127.0.0.1", "::ffff:192.0.2.1"};
var pTableProvider = new ClickHouseTableProvider("ptable", users.Length);
pTableProvider.AddColumn("id", Enumerable.Range(1, users.Length));
pTableProvider.AddColumn("user", users);
// The settings of the column are similar to the settings of parameter
var ipColumn = pTableProvider.AddColumn("ip", ips);
ipColumn.ClickHouseDbType = ClickHouseDbType.IpV6;
ipColumn.IsNullable = false;
cmd.TableProviders.Add(pTableProvider);
using var reader = cmd.ExecuteReader();
while(reader.Read())
{
// Reading the data
}
```
And here is a bit more practical example demonstrating how a temporary table can be used with `IN` clause:
```C#
using var connection = new ClickHouseConnection(connectionStr);
connection.Open();
var cmd = cn.CreateCommand("SELECT toInt32(number) FROM numbers(100000) WHERE number IN param_table");
var tableProvider = new ClickHouseTableProvider("param_table", 100);
tableProvider.AddColumn(Enumerable.Range(500, int.MaxValue / 2));
cmd.TableProviders.Add(tableProvider);
using var reader = cmd.ExecuteReader();
while(reader.Read())
{
// Reading only 100 rows
}
```
## Implementation details
Unfortunately, parameters are not supported by the ClickHouse binary protocol. Which means that it's a client-side feature. ClickHouseClient passes
parameters to the server as a table with one row. The name of this table is unique for each query. It is generated based on `Guid` so there should be
no collision with names of existing tables.
ClickHouseClient analyzes the query and substitutes parameters with `SELECT` subquery. For example, the query
```SQL
SELECT * FROM some_table WHERE id = {id:UInt32}
```
will be transformed before sending to the server to
```SQL
SELECT * FROM some_table WHERE id = (CAST((SELECT _b3dcef95634b4fcfbf67624a39ce2e85.id FROM _b3dcef95634b4fcfbf67624a39ce2e85) AS UInt32))
```
where `_b3dcef95634b4fcfbf67624a39ce2e85` is the name of the table with parameters.
================================================
FILE: docs/TypeMapping.md
================================================
# Type mappings
**ClickHouse type**. The type of the column.
**Default type**. This is the type returned by `Octonica.ClickHouseClient.ClickHouseDataReader.GetFieldType(int ordinal)`. The method `Octonica.ClickHouseClient.ClickHouseDataReader.GetValue(int ordinal)` returns either a value of the default type or `System.DBNull`.
**Supported types**. The value can be converted to one of this types.
**ClickHouseDataReader's method**. The method dedicated to the default type.
You can get the value of one of supported types by calling `GetFieldValue<T>(int ordinal)` or `GetFieldValue<T>(int ordinal, T? nullValue)`. The latter doesn't throw an error on NULL value.
| ClickHouse type | Default type | Supported types | ClickHouseDataReader's method |
|---|---|---|---|
| Int8 | sbyte | short, int, long | `GetSByte` |
| Int16 | short | int, long | `GetInt16` |
| Int32 | int | long | `GetInt32` |
| Int64 | long | | `GetInt64` |
| Int128 | System.Numerics.BigInteger | | `GetBigInteger` |
| Int256 | System.Numerics.BigInteger | | `GetBigInteger` |
| UInt8 | byte | ushort, uint, ulong, int, long | `GetByte` |
| UInt16 | ushort | uint, ulong, int, long | `GetUInt16` |
| UInt32 | uint | ulong, long | `GetUInt132` |
| UInt64 | ulong | | `GetUInt64` |
| UInt128 | System.Numerics.BigInteger | | `GetBigInteger` |
| UInt256 | System.Numerics.BigInteger | | `GetBigInteger` |
| Float32 | float | double | `GetFloat` |
| Float64 | double | | `GetDouble` |
| Decimal | decimal | | `GetDecimal` |
| Date\* | System.DateOnly | System.DateTime | `GetDate` |
| Date32\* | System.DateOnly | System.DateTime | `GetDate` |
| DateTime | System.DateTimeOffset | System.DateTime | `GetDateTimeOffset` |
| DateTime64 | System.DateTimeOffset | System.DateTime | `GetDateTimeOffset` |
| String | string | char[], byte[] | `GetString` |
| FixedString | byte[] | string, char[] | |
| UUID | System.Guid | | `GetGuid` |
| IPv4 | System.Net.IPAddress | string, int, uint | `GetIPAddress` |
| IPv6 | System.Net.IPAddress | string | `GetIPAddress` |
| Enum8 | string | sbyte, short, int, long | |
| Enum16 | string | short, int, long | |
| Nothing | System.DBNull | | `GetValue` |
| Nullable(T) | T? | | |
| Array(T) | T[] | | |
| Tuple(T1, ... Tn) | System.Tuple<T1, ... Tn> | System.ValueTuple<T1, ... Tn> | |
| LowCardinality<T> | T | | The method for `T` |
| Map(TKey, TValue) | System.Collections.Generic.KeyValuePair<TKey, TValue>[] | System.Tuple<TKey, TValue>[], System.ValueTuple<TKey, TValue>[] | |
\* The type `System.DateOnly` is available since .NET 6.0. For previous .NET versions dates are mapped to `System.DateTime`.
================================================
FILE: src/ConnectionSettingsHelper.cs
================================================
#region License Apache 2.0
/* Copyright 2020-2023 Octonica
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#endregion
using System;
using System.IO;
namespace Octonica.ClickHouseClient
{
internal static class ConnectionSettingsHelper
{
public static ClickHouseConnectionSettings GetConnectionSettings(Action<ClickHouseConnectionStringBuilder>? updateSettings = null)
{
return GetConnectionSettingsInternal(updateSettings).settings;
}
public static string GetConnectionString()
{
return GetConnectionSettingsInternal(null).connectionString;
}
public static string GetConnectionString(Action<ClickHouseConnectionStringBuilder> updateSettings)
{
var settings = GetConnectionSettings(updateSettings);
var builder = new ClickHouseConnectionStringBuilder(settings);
return builder.ConnectionString;
}
private static (ClickHouseConnectionSettings settings, string connectionString) GetConnectionSettingsInternal(Action<ClickHouseConnectionStringBuilder>? updateSettings)
{
const string envVariableName = "CLICKHOUSE_TEST_CONNECTION";
const string configFileName = "clickHouse.dbconfig";
const string conStrExample = "host=clickhouse.example.com; port=9000; user=default;";
var configTextFromEnvVar = Environment.GetEnvironmentVariable(envVariableName);
if (configTextFromEnvVar != null)
{
try
{
var builder = new ClickHouseConnectionStringBuilder(configTextFromEnvVar);
updateSettings?.Invoke(builder);
return (builder.BuildSettings(), configTextFromEnvVar);
}
catch (Exception ex)
{
throw new InvalidOperationException($"The connection string from the environment variable '{envVariableName}' is not valid. Connection string example: '{conStrExample}'. {ex.Message}", ex);
}
}
string configPath = Path.Combine(AppContext.BaseDirectory, configFileName);
if (!File.Exists(configPath))
{
throw new InvalidOperationException(
"The connection string is required. " +
$"Please, set the environment variable '{envVariableName}' or write the connection string to the file '{configFileName}'. " +
$"Connection string example: '{conStrExample}'.");
}
string configText = File.ReadAllText(configPath);
try
{
var builder = new ClickHouseConnectionStringBuilder(configText);
updateSettings?.Invoke(builder);
return (builder.BuildSettings(), configText);
}
catch (Exception ex)
{
throw new InvalidOperationException($"The connection string from the file '{configFileName}' is not valid. Connection string example: '{conStrExample}'. {ex.Message}", ex);
}
}
}
}
================================================
FILE: src/Octonica.ClickHouseClient/ClickHouseBinaryProtocolReader.cs
================================================
#region License Apache 2.0
/* Copyright 2019-2021, 2023 Octonica
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#endregion
using System;
using System.Buffers;
using System.IO;
using System.Text;
using System.Threading;
using System.Threading.Tasks;
using Octonica.ClickHouseClient.Exceptions;
using Octonica.ClickHouseClient.Protocol;
using Octonica.ClickHouseClient.Utils;
namespace Octonica.ClickHouseClient
{
internal class ClickHouseBinaryProtocolReader: IDisposable
{
private readonly ReadWriteBuffer _buffer;
private readonly Stream _stream;
private readonly int _bufferSize;
private CompressionAlgorithm _currentCompression;
private CompressionDecoderBase? _compressionDecoder;
public ClickHouseBinaryProtocolReader(Stream stream, int bufferSize)
{
_buffer = new ReadWriteBuffer(bufferSize);
_stream = stream ?? throw new ArgumentNullException(nameof(stream));
_bufferSize = bufferSize;
}
internal void BeginDecompress(CompressionAlgorithm algorithm)
{
if (algorithm != CompressionAlgorithm.None)
{
if (_compressionDecoder != null && _compressionDecoder.Algorithm != algorithm)
{
_compressionDecoder?.Dispose();
_compressionDecoder = null;
}
else
{
_compressionDecoder?.Reset();
}
}
switch (algorithm)
{
case CompressionAlgorithm.None:
_currentCompression = algorithm;
return;
case CompressionAlgorithm.Lz4:
if (_compressionDecoder == null)
_compressionDecoder = new Lz4CompressionDecoder(_bufferSize);
_currentCompression = algorithm;
break;
default:
throw new ArgumentOutOfRangeException(nameof(algorithm), algorithm, null);
}
}
internal void EndDecompress()
{
_currentCompression = CompressionAlgorithm.None;
}
public async ValueTask<string> ReadString(bool async, CancellationToken cancellationToken)
{
var size = await ReadSize(async, cancellationToken);
if (size == 0)
return string.Empty;
ReadOnlySequence<byte> readResult;
do
{
readResult = await Read(async, cancellationToken);
if (readResult.Length >= size)
break;
AdvanceReader(readResult, 0);
await Advance(async, cancellationToken);
} while (true);
string result;
var encoding = Encoding.UTF8;
var stringSpan = readResult.Slice(readResult.Start, readResult.GetPosition(size));
if (stringSpan.IsSingleSegment)
{
result = encoding.GetString(stringSpan.FirstSpan);
}
else
{
var buffer = stringSpan.ToArray();
result = encoding.GetString(buffer);
}
AdvanceReader(readResult, (int) stringSpan.Length);
return result;
}
public async ValueTask<int> Read7BitInt32(bool async, CancellationToken cancellationToken)
{
var longValue = await Read7BitInteger(async, cancellationToken);
if (longValue > uint.MaxValue)
throw new FormatException(); //TODO: exception
return unchecked((int) longValue);
}
public ValueTask<ulong> Read7BitUInt64(bool async, CancellationToken cancellationToken)
{
return Read7BitInteger(async, cancellationToken);
}
public async ValueTask<int> ReadInt32(bool async, CancellationToken cancellationToken)
{
do
{
var readResult = await Read(async, cancellationToken);
if (readResult.Length < sizeof(int))
{
AdvanceReader(readResult, 0);
await Advance(async, cancellationToken);
continue;
}
int result;
if (readResult.FirstSpan.Length >= sizeof(int))
result = BitConverter.ToInt32(readResult.FirstSpan);
else
{
var tmpArr = readResult.Slice(0, sizeof(int)).ToArray();
result = BitConverter.ToInt32(tmpArr, 0);
}
AdvanceReader(readResult, sizeof(int));
return result;
} while (true);
}
public async ValueTask<int> ReadSize(bool async, CancellationToken cancellationToken)
{
var longValue = await Read7BitInteger(async, cancellationToken);
if (longValue > int.MaxValue)
throw new FormatException(); //TODO: exception
return (int) longValue;
}
public async ValueTask<bool> ReadBool(bool async, CancellationToken cancellationToken)
{
return await ReadByte(async, cancellationToken) != 0;
}
public async ValueTask<byte> ReadByte(bool async, CancellationToken cancellationToken)
{
var readResult = await Read(async, cancellationToken);
var result = readResult.FirstSpan[0];
AdvanceReader(readResult, 1);
return result;
}
private async ValueTask<ulong> Read7BitInteger(bool async, CancellationToken cancellationToken)
{
do
{
var readResult = await Read(async, cancellationToken);
if (!TryRead7BitInteger(readResult, out var result, out var bytesRead))
{
AdvanceReader(readResult, 0);
await Advance(async, cancellationToken);
}
else
{
AdvanceReader(readResult, bytesRead);
return result;
}
} while (true);
}
public async ValueTask<SequenceSize> ReadRaw(Func<ReadOnlySequence<byte>, SequenceSize> readBytes, bool async, CancellationToken cancellationToken)
{
if (readBytes == null)
throw new ArgumentNullException(nameof(readBytes));
var readResult = await Read(async, cancellationToken);
var size = readBytes(readResult);
AdvanceReader(readResult, size.Bytes);
return size;
}
public async ValueTask SkipBytes(int bytesCount, bool async, CancellationToken cancellationToken)
{
if (bytesCount < 0)
throw new ArgumentException("The number of bytes for is negative.", nameof(bytesCount));
if (bytesCount == 0)
return;
var c = bytesCount;
while (c > 0)
{
var readResult = await Read(async, cancellationToken);
var consumed = Math.Min(c, (int)readResult.Length);
AdvanceReader(readResult, consumed);
c -= consumed;
}
}
internal bool TryPeekByte(out byte value)
{
if (_currentCompression != CompressionAlgorithm.None)
throw new NotImplementedException();
var readResult = _buffer.Read();
if (readResult.IsEmpty)
{
value = 0;
return false;
}
value = readResult.FirstSpan[0];
return true;
}
public async ValueTask<IServerMessage> ReadMessage(int protocolRevision, bool throwOnUnknownMessage, bool async, CancellationToken cancellationToken)
{
var messageCode = (ServerMessageCode) await Read7BitInt32(async, cancellationToken);
switch (messageCode)
{
case ServerMessageCode.Hello:
return await ServerHelloMessage.Read(this, protocolRevision, async, cancellationToken);
case ServerMessageCode.Data:
case ServerMessageCode.Totals:
case ServerMessageCode.Extremes:
return await ServerDataMessage.Read(this, messageCode, async, cancellationToken);
case ServerMessageCode.Error:
return await ServerErrorMessage.Read(this, async, cancellationToken);
case ServerMessageCode.Progress:
return await ServerProgressMessage.Read(this, protocolRevision, async, cancellationToken);
case ServerMessageCode.Pong:
return ServerPongMessage.Instance;
case ServerMessageCode.EndOfStream:
return ServerEndOfStreamMessage.Instance;
case ServerMessageCode.ProfileInfo:
return await ServerProfileInfoMessage.Read(this, async, cancellationToken);
case ServerMessageCode.TableColumns:
return await ServerTableColumnsMessage.Read(this, async, cancellationToken);
case ServerMessageCode.TableStatusResponse:
case ServerMessageCode.Log:
case ServerMessageCode.PartUuids:
case ServerMessageCode.ReadTaskRequest:
case ServerMessageCode.MergeTreeAllRangesAnnouncement:
case ServerMessageCode.MergeTreeReadTaskRequest:
throw new NotImplementedException($"A message of type \"{messageCode}\" is not supported.");
case ServerMessageCode.ProfileEvents:
return await ServerDataMessage.Read(this, messageCode, async, cancellationToken);
case ServerMessageCode.TimezoneUpdate:
return await ServerTimeZoneUpdateMessage.Read(this, async, cancellationToken);
default:
if (throwOnUnknownMessage)
throw new ClickHouseException(ClickHouseErrorCodes.ProtocolUnexpectedResponse, $"Internal error. Not supported message code (0x{messageCode:X}) received from the server.");
return new UnknownServerMessage(messageCode);
}
}
private async ValueTask<ReadOnlySequence<byte>> Read(bool async, CancellationToken cancellationToken)
{
if (_currentCompression == CompressionAlgorithm.None)
return await ReadFromPipe(async, cancellationToken);
if (_compressionDecoder == null)
throw new ClickHouseException(ClickHouseErrorCodes.InternalError, "Internal error. An encoder is not initialized.");
if (!_compressionDecoder.IsCompleted)
await Advance(async, cancellationToken);
var sequence = _compressionDecoder.Read();
while (sequence.IsEmpty)
{
await Advance(async, cancellationToken);
sequence = _compressionDecoder.Read();
}
return sequence;
}
private async ValueTask<ReadOnlySequence<byte>> ReadFromPipe(bool async, CancellationToken cancellationToken)
{
do
{
var readResult = _buffer.Read();
if (!readResult.IsEmpty)
return readResult;
await AdvanceBuffer(async, cancellationToken);
} while (true);
}
private void AdvanceReader(ReadOnlySequence<byte> readResult, int consumedPosition)
{
if (_currentCompression == CompressionAlgorithm.None)
{
_buffer.ConfirmRead(consumedPosition);
}
else
{
if (_compressionDecoder == null)
throw new ClickHouseException(ClickHouseErrorCodes.InternalError, "Internal error. A decoder is not initialized.");
_compressionDecoder.AdvanceReader(readResult.GetPosition(consumedPosition));
}
}
internal async ValueTask Advance(bool async, CancellationToken cancellationToken)
{
if (_currentCompression != CompressionAlgorithm.None)
{
if (_compressionDecoder == null)
throw new ClickHouseException(ClickHouseErrorCodes.InternalError, "Internal error. A decoder is not initialized.");
if (_compressionDecoder.IsCompleted)
{
while (true)
{
var buffer = await ReadFromPipe(async, cancellationToken);
var size = _compressionDecoder.ReadHeader(buffer);
if (size >= 0)
{
_buffer.ConfirmRead(size);
break;
}
await AdvanceBuffer(async, cancellationToken);
}
}
while (!_compressionDecoder.IsCompleted)
{
var sequence = await ReadFromPipe(async, cancellationToken);
var consumed = _compressionDecoder.ConsumeNext(sequence);
_buffer.ConfirmRead(consumed);
}
return;
}
await AdvanceBuffer(async, cancellationToken);
}
private async ValueTask AdvanceBuffer(bool async, CancellationToken cancellationToken)
{
var buffer = _buffer.GetMemory();
int bytesRead;
if (async)
{
if (cancellationToken == CancellationToken.None && _stream.ReadTimeout >= 0)
{
var timeout = TimeSpan.FromMilliseconds(_stream.ReadTimeout);
using var tokenSource = new CancellationTokenSource(timeout);
try
{
bytesRead = await _stream.ReadAsync(buffer, tokenSource.Token);
}
catch (OperationCanceledException ex)
{
throw new IOException($"Unable to read data from the transport connection: timeout exceeded ({timeout}).", ex);
}
}
else
{
bytesRead = await _stream.ReadAsync(buffer, cancellationToken);
}
}
else
{
bytesRead = _stream.Read(buffer.Span);
cancellationToken.ThrowIfCancellationRequested();
}
if (bytesRead == 0)
throw new EndOfStreamException($"Reached an unexpected end of the server's response. {ClickHouseConnectionStringBuilder.DefaultClientName} expected at least one more byte in the response.");
_buffer.ConfirmWrite(bytesRead);
_buffer.Flush();
}
public static bool TryRead7BitInteger(ReadOnlySequence<byte> sequence, out ulong value, out int bytesRead)
{
ulong result = 0;
int i = 0, shiftSize = 0;
foreach (var slice in sequence)
{
for (int j = 0; j < slice.Length; j++)
{
var byteValue = slice.Span[j];
result |= (byteValue & (ulong)0x7F) << shiftSize;
i++;
if ((byteValue & 0x80) == 0x80)
{
shiftSize += 7;
if (shiftSize > sizeof(ulong) * 8 - 7)
throw new FormatException(); //TODO: exception
}
else
{
value = result;
bytesRead = i;
return true;
}
}
}
value = 0;
bytesRead = 0;
return false;
}
public void Dispose()
{
_compressionDecoder?.Dispose();
}
}
}
================================================
FILE: src/Octonica.ClickHouseClient/ClickHouseBinaryProtocolWriter.cs
================================================
#region License Apache 2.0
/* Copyright 2019-2021, 2023-2024 Octonica
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#endregion
using System;
using System.Diagnostics;
using System.IO;
using System.Text;
using System.Threading;
using System.Threading.Tasks;
using Octonica.ClickHouseClient.Exceptions;
using Octonica.ClickHouseClient.Protocol;
using Octonica.ClickHouseClient.Utils;
namespace Octonica.ClickHouseClient
{
internal class ClickHouseBinaryProtocolWriter : IDisposable
{
private readonly int _bufferSize;
private readonly ReadWriteBuffer _buffer;
private readonly Stream _stream;
private CompressionAlgorithm _currentCompression;
private CompressionEncoderBase? _compressionEncoder;
public ClickHouseBinaryProtocolWriter(Stream stream, int bufferSize)
{
_buffer = new ReadWriteBuffer(bufferSize);
_stream = stream ?? throw new ArgumentNullException(nameof(stream));
_bufferSize = bufferSize;
}
public async ValueTask Flush(bool async, CancellationToken cancellationToken)
{
if (_currentCompression != CompressionAlgorithm.None)
throw new ClickHouseException(ClickHouseErrorCodes.InternalError, "Internal error. The stream can't be flushed because it's compression is not completed.");
_buffer.Flush();
var readResult = _buffer.Read();
if (readResult.IsEmpty)
return;
foreach (var buffer in readResult)
{
if (async)
await WriteWithTimeoutAsync((networkStream, ct) => networkStream.WriteAsync(buffer, ct).AsTask(), cancellationToken);
else
_stream.Write(buffer.Span);
}
_buffer.ConfirmRead((int) readResult.Length);
if (async)
await WriteWithTimeoutAsync((networkStream, ct) => networkStream.FlushAsync(ct), cancellationToken);
else
_stream.Flush();
}
public void Discard()
{
_buffer.Discard();
var readResult = _buffer.Read();
if (!readResult.IsEmpty)
_buffer.ConfirmRead((int) readResult.Length);
_currentCompression = CompressionAlgorithm.None;
}
public void BeginCompress(CompressionAlgorithm algorithm, int compressionBlockSize)
{
if (_compressionEncoder != null)
{
if (_compressionEncoder.Algorithm != algorithm)
{
_compressionEncoder.Dispose();
_compressionEncoder = null;
}
else
{
_currentCompression = _compressionEncoder.Algorithm;
_compressionEncoder.Reset();
return;
}
}
switch (algorithm)
{
case CompressionAlgorithm.None:
break;
case CompressionAlgorithm.Lz4:
_currentCompression = algorithm;
_compressionEncoder = new Lz4CompressionEncoder(_bufferSize, compressionBlockSize);
break;
default:
throw new NotSupportedException($"Compression algorithm \"{algorithm}\" is not supported.");
}
}
public void EndCompress()
{
_compressionEncoder?.Complete(_buffer);
_currentCompression = CompressionAlgorithm.None;
}
public void WriteString(string value)
{
if (value == null)
throw new ArgumentNullException(nameof(value));
var encoding = Encoding.UTF8;
var length = encoding.GetByteCount(value);
Write7BitInteger((uint) length);
if (length == 0)
return;
var charSpan = value.AsSpan();
var byteSpan = GetSpan(length);
var count = Encoding.UTF8.GetBytes(charSpan, byteSpan);
Debug.Assert(count == length);
Advance(length);
}
public SequenceSize WriteRaw(Func<Memory<byte>, SequenceSize> writeBytes)
{
return WriteRaw(0, writeBytes);
}
public SequenceSize WriteRaw(int sizeHint, Func<Memory<byte>, SequenceSize> writeBytes)
{
if (writeBytes == null)
throw new ArgumentNullException(nameof(writeBytes));
SequenceSize size;
var memory = sizeHint > 0 ? GetMemory(sizeHint) : GetMemory();
if (!memory.IsEmpty)
{
try
{
size = writeBytes(memory);
}
catch
{
Advance(0);
throw;
}
if (size.Bytes > 0 || size.Elements > 0)
{
Advance(size.Bytes);
return size;
}
}
var bufferSize = _bufferSize;
do
{
Advance(0);
memory = GetMemory(bufferSize);
try
{
size = writeBytes(memory);
}
catch
{
Advance(0);
throw;
}
bufferSize *= 2;
} while (size.Bytes == 0 && size.Elements == 0);
Advance(size.Bytes);
return size;
}
public void WriteInt32(int value)
{
var span = GetSpan(sizeof(int));
var success = BitConverter.TryWriteBytes(span, value);
Debug.Assert(success);
Advance(sizeof(int));
}
public void WriteBool(bool value)
{
WriteByte(value ? (byte) 1 : (byte) 0);
}
public void WriteByte(byte value)
{
var buffer = GetSpan(1);
buffer[0] = value;
Advance(1);
}
public void WriteBytes(ReadOnlySpan<byte> bytes)
{
var span = GetSpan(bytes.Length);
bytes.CopyTo(span);
Advance(bytes.Length);
}
private async Task WriteWithTimeoutAsync(Func<Stream, CancellationToken, Task> writeAsync, CancellationToken cancellationToken)
{
if (cancellationToken == CancellationToken.None && _stream.WriteTimeout >= 0)
{
var timeout = TimeSpan.FromMilliseconds(_stream.WriteTimeout);
using var tokenSource = new CancellationTokenSource(timeout);
try
{
await writeAsync(_stream, tokenSource.Token);
}
catch (OperationCanceledException ex)
{
throw new IOException($"Unable to write data to the transport connection: timeout exceeded ({timeout}).", ex);
}
}
else
{
await writeAsync(_stream, cancellationToken);
}
}
public void Write7BitInt32(int value)
{
var ulongValue = (ulong) unchecked((uint) value);
Write7BitInteger(ulongValue);
}
private void Write7BitInteger(ulong value)
{
ulong v = value;
int totalLength = 0;
var buffer = GetSpan(10);
for (int i = 0; i < buffer.Length; i++)
{
++totalLength;
if (v >= 0x80)
{
buffer[i] = (byte) (v | 0x80);
v >>= 7;
}
else
{
buffer[i] = (byte) v;
Advance(totalLength);
return;
}
}
Advance(totalLength);
}
private Span<byte> GetSpan(int sizeHint)
{
if (_currentCompression != CompressionAlgorithm.None)
{
if (_compressionEncoder == null)
throw new ClickHouseException(ClickHouseErrorCodes.InternalError, "Internal error. An encoder is not initialized.");
return _compressionEncoder.GetSpan(sizeHint);
}
return _buffer.GetMemory(sizeHint).Span;
}
private Memory<byte> GetMemory(int sizeHint)
{
if (_currentCompression == CompressionAlgorithm.None)
return _buffer.GetMemory(sizeHint);
if (_compressionEncoder == null)
throw new ClickHouseException(ClickHouseErrorCodes.InternalError, "Internal error. An encoder is not initialized.");
return _compressionEncoder.GetMemory(sizeHint);
}
private Memory<byte> GetMemory()
{
if (_currentCompression == CompressionAlgorithm.None)
return _buffer.GetMemory();
if (_compressionEncoder == null)
throw new ClickHouseException(ClickHouseErrorCodes.InternalError, "Internal error. An encoder is not initialized.");
return _compressionEncoder.GetMemory();
}
private void Advance(int bytes)
{
if (_currentCompression != CompressionAlgorithm.None)
{
if (_compressionEncoder == null)
throw new ClickHouseException(ClickHouseErrorCodes.InternalError, "Internal error. An encoder is not initialized.");
_compressionEncoder.Advance(bytes);
}
else
{
_buffer.ConfirmWrite(bytes);
}
}
public static int TryWrite7BitInteger(Span<byte> buffer, ulong value)
{
ulong v = value;
int count = 0;
while (true)
{
if (buffer.Length == count)
return 0;
if (v >= 0x80)
{
buffer[count++] = (byte) (v | 0x80);
v >>= 7;
}
else
{
buffer[count++] = (byte) v;
break;
}
}
return count;
}
public void Dispose()
{
_compressionEncoder?.Dispose();
}
}
}
================================================
FILE: src/Octonica.ClickHouseClient/ClickHouseColumnSettings.cs
================================================
#region License Apache 2.0
/* Copyright 2019-2021 Octonica
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#endregion
using System;
using System.Text;
using Octonica.ClickHouseClient.Types;
using Octonica.ClickHouseClient.Utils;
namespace Octonica.ClickHouseClient
{
/// <summary>
/// Represents additional column settings that affect the behavior of <see cref="ClickHouseDataReader"/> and <see cref="ClickHouseColumnWriter"/>.
/// </summary>
public class ClickHouseColumnSettings
{
private ITypeDispatcher? _columnTypeDispatcher;
/// <summary>
/// Gets encoding applied to strings when reading from the database or writing to the database.
/// </summary>
public Encoding? StringEncoding { get; }
/// <summary>
/// Gets the converter applied to enums.
/// </summary>
public IClickHouseEnumConverter? EnumConverter { get; }
/// <summary>
/// Gets the explicitly defined type of the column. This value overrides the type of the field for <see cref="ClickHouseDataReader"/>
/// and <see cref="ClickHouseColumnWriter"/>. <see cref="ClickHouseDataReader"/> will try to convert a column's value to this type.
/// <see cref="ClickHouseColumnWriter"/> will expect a collection of items of this type as input.
/// </summary>
public Type? ColumnType { get; }
/// <summary>
/// Initializes a new instance of <see cref="ClickHouseConnectionSettings"/> class with the specified encoding.
/// </summary>
/// <param name="stringEncoding">The encoding applied to strings when reading from the database or writing to the database.</param>
public ClickHouseColumnSettings(Encoding stringEncoding)
{
StringEncoding = stringEncoding ?? throw new ArgumentNullException(nameof(stringEncoding));
}
/// <summary>
/// Initializes a new instance of <see cref="ClickHouseConnectionSettings"/> class with the specified enum converter.
/// </summary>
/// <param name="enumConverter">The converter applied to enums.</param>
public ClickHouseColumnSettings(IClickHouseEnumConverter enumConverter)
{
EnumConverter = enumConverter ?? throw new ArgumentNullException(nameof(enumConverter));
}
/// <summary>
/// Initializes a new instance of <see cref="ClickHouseConnectionSettings"/> class with the specified column type.
/// </summary>
/// <param name="columnType">
/// The explicitly defined type of the column. This value overrides the type of the field for <see cref="ClickHouseDataReader"/>
/// and <see cref="ClickHouseColumnWriter"/>. <see cref="ClickHouseDataReader"/> will try to convert a column's value to this type.
/// <see cref="ClickHouseColumnWriter"/> will expect a collection of items of this type as input.
/// </param>
public ClickHouseColumnSettings(Type columnType)
{
ColumnType = columnType ?? throw new ArgumentException(nameof(columnType));
}
/// <summary>
/// Initializes a new instance of <see cref="ClickHouseConnectionSettings"/> class with multiple specified parameters.
/// </summary>
/// <param name="stringEncoding">The encoding applied to strings when reading from the database or writing to the database.</param>
/// <param name="enumConverter">The converter applied to enums.</param>
/// <param name="columnType">
/// The explicitly defined type of the column. This value overrides the type of the field for <see cref="ClickHouseDataReader"/>
/// and <see cref="ClickHouseColumnWriter"/>. <see cref="ClickHouseDataReader"/> will try to convert a column's value to this type.
/// <see cref="ClickHouseColumnWriter"/> will expect a collection of items of this type as input.
/// </param>
public ClickHouseColumnSettings(Encoding? stringEncoding = null, IClickHouseEnumConverter? enumConverter = null, Type? columnType = null)
{
StringEncoding = stringEncoding;
EnumConverter = enumConverter;
ColumnType = columnType;
}
internal ITypeDispatcher? GetColumnTypeDispatcher()
{
if (ColumnType == null)
return null;
return _columnTypeDispatcher ??= TypeDispatcher.Create(ColumnType);
}
}
}
================================================
FILE: src/Octonica.ClickHouseClient/ClickHouseColumnWriter.cs
================================================
#region License Apache 2.0
/* Copyright 2019-2021, 2023 Octonica
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#endregion
using System;
using System.Collections;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.Diagnostics;
using System.Diagnostics.CodeAnalysis;
using System.Linq;
using System.Runtime.CompilerServices;
using System.Threading;
using System.Threading.Tasks;
using Octonica.ClickHouseClient.Exceptions;
using Octonica.ClickHouseClient.Protocol;
using Octonica.ClickHouseClient.Types;
using Octonica.ClickHouseClient.Utils;
namespace Octonica.ClickHouseClient
{
/// <summary>
/// Provides a way of writing set of columns to a ClickHouse database. This class cannot be inherited.
/// </summary>
public sealed class ClickHouseColumnWriter : IDisposable, IAsyncDisposable
{
private readonly ClickHouseTcpClient.Session _session;
private readonly ClientQueryMessage _query;
private readonly ReadOnlyCollection<ColumnInfo> _columns;
private ClickHouseColumnSettings?[]? _columnSettings;
private int? _rowsPerBlock;
private bool _endOfStream;
/// <summary>
/// Gets the number of fields (columns) in the table.
/// </summary>
public int FieldCount => _columns.Count;
/// <summary>
/// Gets the value indicating whether the writer is closed.
/// </summary>
/// <returns><see langword="true"/> if the reader is closed; otherwise <see langword="false"/>.</returns>
public bool IsClosed => _session.IsDisposed || _session.IsFailed;
/// <summary>
/// Gets or sets the maximal number of rows in a single block of data.
/// </summary>
/// <returns>The maximal number of rows in a single block of data. <see langword="null"/> if the size of the block is not limited.</returns>
public int? MaxBlockSize
{
get => _rowsPerBlock;
set
{
if (value <= 0)
throw new ArgumentException("A number of rows in a block must be greater than zero.");
_rowsPerBlock = value;
}
}
/// <summary>
/// Gets the query execution progress reported by the server.
/// </summary>
public ClickHouseQueryExecutionProgress ExecutionProgress { get; private set; }
internal ClickHouseColumnWriter(ClickHouseTcpClient.Session session, ClientQueryMessage query, ReadOnlyCollection<ColumnInfo> columns)
{
_session = session ?? throw new ArgumentNullException(nameof(session));
_query = query ?? throw new ArgumentNullException(nameof(query));
_columns = columns;
if (columns.Count <= 100)
MaxBlockSize = 8000;
else if (columns.Count >= 1000)
MaxBlockSize = 800;
else
MaxBlockSize = 8800 - 8 * columns.Count;
}
internal static async ValueTask<ClickHouseTable> ReadTableMetadata(ClickHouseTcpClient.Session session, string queryText, bool async, CancellationToken cancellationToken)
{
var msg = await session.ReadMessage(async, cancellationToken);
switch (msg.MessageCode)
{
case ServerMessageCode.Error:
throw ((ServerErrorMessage)msg).Exception.CopyWithQuery(queryText);
case ServerMessageCode.TableColumns:
break;
default:
throw new ClickHouseException(ClickHouseErrorCodes.ProtocolUnexpectedResponse, $"Unexpected server message. Received the message of type {msg.MessageCode}.");
}
msg = await session.ReadMessage(async, cancellationToken);
ClickHouseTable data;
switch (msg.MessageCode)
{
case ServerMessageCode.Error:
throw ((ServerErrorMessage)msg).Exception.CopyWithQuery(queryText);
case ServerMessageCode.Data:
data = await session.ReadTable((ServerDataMessage)msg, null, async, cancellationToken);
break;
default:
throw new ClickHouseException(ClickHouseErrorCodes.ProtocolUnexpectedResponse, $"Unexpected server message. Received the message of type {msg.MessageCode}.");
}
return data;
}
/// <inheritdoc cref="ClickHouseDataReader.ConfigureColumn(string, ClickHouseColumnSettings)"/>
public void ConfigureColumn(string name, ClickHouseColumnSettings columnSettings)
{
var index = GetOrdinal(name);
if (index < 0)
throw new ArgumentException($"A column with the name \"{name}\" not found.", nameof(name));
ConfigureColumn(index, columnSettings);
}
/// <inheritdoc cref="ClickHouseDataReader.ConfigureColumn(int, ClickHouseColumnSettings)"/>
public void ConfigureColumn(int ordinal, ClickHouseColumnSettings columnSettings)
{
if (_columnSettings == null)
_columnSettings = new ClickHouseColumnSettings?[_columns.Count];
_columnSettings[ordinal] = columnSettings;
}
/// <inheritdoc cref="ClickHouseDataReader.ConfigureDataReader(ClickHouseColumnSettings)"/>
public void ConfigureColumnWriter(ClickHouseColumnSettings columnSettings)
{
if (_columnSettings == null)
_columnSettings = new ClickHouseColumnSettings?[_columns.Count];
for (int i = 0; i < _columns.Count; i++)
_columnSettings[i] = columnSettings;
}
/// <inheritdoc cref="ClickHouseDataReader.GetFieldTypeInfo(int)"/>
public IClickHouseTypeInfo GetFieldTypeInfo(int ordinal)
{
return _columns[ordinal].TypeInfo;
}
/// <inheritdoc cref="ClickHouseDataReader.GetName(int)"/>
public string GetName(int ordinal)
{
return _columns[ordinal].Name;
}
/// <inheritdoc cref="ClickHouseDataReader.GetDataTypeName(int)"/>
public string GetDataTypeName(int ordinal)
{
return _columns[ordinal].TypeInfo.ComplexTypeName;
}
/// <inheritdoc cref="ClickHouseDataReader.GetFieldType(int)"/>
public Type GetFieldType(int ordinal)
{
// This method should implement the same logic as ClickHouseDataReader.GetFieldType
var type = _columnSettings?[ordinal]?.ColumnType;
type ??= _columns[ordinal].TypeInfo.GetFieldType();
return Nullable.GetUnderlyingType(type) ?? type;
}
/// <inheritdoc cref="ClickHouseDataReader.GetOrdinal(string)"/>
public int GetOrdinal(string name)
{
if (name == null)
throw new ArgumentNullException(nameof(name));
return CommonUtils.GetColumnIndex(_columns, name);
}
/// <summary>
/// Writes a single row to the table.
/// </summary>
/// <param name="values">The list of column values.</param>
/// <remarks>Please note that the method always commits a transaction. No subsequent call of <see cref="Commit"/> is required.</remarks>
public void WriteRow(params object?[] values)
{
TaskHelper.WaitNonAsyncTask(WriteRow(values, commit: true, async: false, CancellationToken.None));
}
/// <summary>
/// Writes a single row to the table.
/// </summary>
/// <param name="values">The list of column values.</param>
/// <returns>A <see cref="Task"/> representing asyncronous operation.</returns>
/// <remarks>Please note that the method always commits a transaction. No subsequent call of <see cref="Commit"/> is required.</remarks>
public void WriteRow(IReadOnlyCollection<object?> values)
{
TaskHelper.WaitNonAsyncTask(WriteRow(values, commit: true, async: false, CancellationToken.None));
}
/// <summary>
/// Writes a single row to the table.
/// </summary>
/// <param name="values">The list of column values.</param>
/// <param name="commit">
/// If <see langword="true"/>, commits the transaction immediately after writing a row (the same mode as <see cref="ClickHouseTransactionMode.Block"/>).
/// If <see langword="false"/>, leaves the transaction open (the same mode as <see cref="ClickHouseTransactionMode.Manual"/>).
/// </param>
/// <returns>A <see cref="Task"/> representing asyncronous operation.</returns>
public void WriteRow(IReadOnlyCollection<object?> values, bool commit)
{
TaskHelper.WaitNonAsyncTask(WriteRow(values, commit, async: false, CancellationToken.None));
}
/// <summary>
/// Asyncronously writes a single row to the table.
/// </summary>
/// <param name="values">The list of column values.</param>
/// <returns>A <see cref="Task"/> representing asyncronous operation.</returns>
/// <remarks>Please note that the method always commits a transaction. No subsequent call of <see cref="CommitAsync(CancellationToken)"/> is required.</remarks>
public async Task WriteRowAsync(IReadOnlyCollection<object?> values)
{
await WriteRow(values, commit: true, async: true, CancellationToken.None);
}
/// <summary>
/// Asyncronously writes a single row to the table.
/// </summary>
/// <param name="values">The list of column values.</param>
/// <param name="commit">
/// If <see langword="true"/>, commits the transaction immediately after writing a row (the same mode as <see cref="ClickHouseTransactionMode.Block"/>).
/// If <see langword="false"/>, leaves the transaction open (the same mode as <see cref="ClickHouseTransactionMode.Manual"/>).
/// </param>
/// <returns>A <see cref="Task"/> representing asyncronous operation.</returns>
public async Task WriteRowAsync(IReadOnlyCollection<object?> values, bool commit)
{
await WriteRow(values, commit, async: true, CancellationToken.None);
}
/// <summary>
/// Asyncronously writes a single row to the table.
/// </summary>
/// <param name="values">The list of column values.</param>
/// <param name="cancellationToken">The cancellation instruction.</param>
/// <returns>A <see cref="Task"/> representing asyncronous operation.</returns>
/// <remarks>Please note that the method always commits a transaction. No subsequent call of <see cref="CommitAsync(CancellationToken)"/> is required.</remarks>
public async Task WriteRowAsync(IReadOnlyCollection<object?> values, CancellationToken cancellationToken)
{
await WriteRow(values, commit: true, async: true, cancellationToken);
}
/// <summary>
/// Asyncronously writes a single row to the table.
/// </summary>
/// <param name="values">The list of column values.</param>
/// <param name="commit">
/// If <see langword="true"/>, commits the transaction immediately after writing a row (the same mode as <see cref="ClickHouseTransactionMode.Block"/>).
/// If <see langword="false"/>, leaves the transaction open (the same mode as <see cref="ClickHouseTransactionMode.Manual"/>).
/// </param>
/// <param name="cancellationToken">The cancellation instruction.</param>
/// <returns>A <see cref="Task"/> representing asyncronous operation.</returns>
public async Task WriteRowAsync(IReadOnlyCollection<object?> values, bool commit, CancellationToken cancellationToken)
{
await WriteRow(values, commit, async: true, cancellationToken);
}
private async ValueTask WriteRow(IReadOnlyCollection<object?> values, bool commit, bool async, CancellationToken cancellationToken)
{
if (values == null)
throw new ArgumentNullException(nameof(values));
if (values.Count != _columns.Count)
throw new ArgumentException("The number of values must be equal to the number of columns.");
var columnWriters = new List<IClickHouseColumnWriter>(_columns.Count);
foreach (var value in values)
{
int i = columnWriters.Count;
var columnInfo = _columns[i];
var settings = _columnSettings?[i];
if (settings?.ColumnType == typeof(object))
{
throw new ClickHouseException(
ClickHouseErrorCodes.InvalidColumnSettings,
$"Type \"{settings.ColumnType}\" should not be used as a type of a column. This type is defined in column settings of the column \"{columnInfo.Name}\" (position {i}).");
}
ITypeDispatcher? typeDispatcher;
SingleRowColumnWriterDispatcher dispatcher;
if (value != null && !(value is DBNull))
{
dispatcher = new SingleRowColumnWriterDispatcher(value, columnInfo, _columnSettings?[i]);
var valueType = value.GetType();
if (settings?.ColumnType != null)
{
if (!settings.ColumnType.IsAssignableFrom(valueType))
{
throw new ClickHouseException(
ClickHouseErrorCodes.ColumnTypeMismatch,
$"The value of the row at the position {i} (column \"{columnInfo.Name}\") can't be converted to the type \"{settings.ColumnType}\". This type is defined in column settings.");
}
typeDispatcher = settings.GetColumnTypeDispatcher();
Debug.Assert(typeDispatcher != null);
}
else
{
typeDispatcher = TypeDispatcher.Create(valueType);
}
}
else if (columnInfo.TypeInfo.TypeName != "Nullable")
{
throw new ClickHouseException(ClickHouseErrorCodes.ColumnTypeMismatch, $"The column \"{columnInfo.Name}\" at the position {i} doesn't support nulls.");
}
else
{
dispatcher = new SingleRowColumnWriterDispatcher(null, columnInfo, _columnSettings?[i]);
if (settings?.ColumnType != null)
{
if (settings.ColumnType.IsValueType && Nullable.GetUnderlyingType(settings.ColumnType) == null)
{
throw new ClickHouseException(
ClickHouseErrorCodes.ColumnTypeMismatch,
$"The value of the row at the position {i} (column \"{columnInfo.Name}\") is null. But the type of this column defined in the settings (\"{settings.ColumnType}\") doesn't allow nulls.");
}
typeDispatcher = settings.GetColumnTypeDispatcher();
Debug.Assert(typeDispatcher != null);
}
else
{
var fieldType = columnInfo.TypeInfo.GetFieldType();
typeDispatcher = TypeDispatcher.Create(fieldType);
}
}
IClickHouseColumnWriter columnWriter;
try
{
columnWriter = typeDispatcher.Dispatch(dispatcher);
}
catch (ClickHouseException ex)
{
throw new ClickHouseException(ex.ErrorCode, $"Column \"{columnInfo.Name}\" (position {i}): {ex.Message}", ex);
}
columnWriters.Add(columnWriter);
}
var table = new ClickHouseTableWriter(string.Empty, 1, columnWriters);
await SendTable(table, commit, async, cancellationToken);
}
/// <summary>
/// Writes the specified columns to the table.
/// <br/>
/// Each column must be an object implementing one of the interfaces:
/// <see cref="IReadOnlyList{T}"/>,
/// <see cref="IList{T}"/>,
/// <see cref="IEnumerable{T}"/> or
/// <see cref="IEnumerable"/>.
/// </summary>
/// <param name="columns">The <see cref="IReadOnlyDictionary{TKey, TValue}"/> object that provides access to columns by their names.</param>
/// <param name="rowCount">The number of rows in columns.</param>
public void WriteTable(IReadOnlyDictionary<string, object?> columns, int rowCount)
{
TaskHelper.WaitNonAsyncTask(WriteTable(columns, rowCount, ClickHouseTransactionMode.Default, false, CancellationToken.None));
}
/// <summary>
/// Writes the specified columns to the table.
/// <br/>
/// Each column must be an object implementing one of the interfaces:
/// <see cref="IReadOnlyList{T}"/>,
/// <see cref="IList{T}"/>,
/// <see cref="IEnumerable{T}"/> or
/// <see cref="IEnumerable"/>.
/// </summary>
/// <param name="columns">The <see cref="IReadOnlyDictionary{TKey, TValue}"/> object that provides access to columns by their names.</param>
/// <param name="rowCount">The number of rows in columns.</param>
/// <param name="transactionMode">The mode of sending write confirmations to the server.See <see cref="ClickHouseTransactionMode"/> for details.</param>
public void WriteTable(IReadOnlyDictionary<string, object?> columns, int rowCount, ClickHouseTransactionMode transactionMode)
{
TaskHelper.WaitNonAsyncTask(WriteTable(columns, rowCount, transactionMode, false, CancellationToken.None));
}
/// <summary>
/// Writes the specified columns to the table.
/// <br/>
/// Each column must be an object implementing one of the interfaces:
/// <see cref="IReadOnlyList{T}"/>,
/// <see cref="IList{T}"/>,
/// <see cref="IEnumerable{T}"/> or
/// <see cref="IEnumerable"/>.
/// </summary>
/// <param name="columns">The list of columns.</param>
/// <param name="rowCount">The number of rows in columns.</param>
public void WriteTable(IReadOnlyList<object?> columns, int rowCount)
{
TaskHelper.WaitNonAsyncTask(WriteTable(columns, rowCount, ClickHouseTransactionMode.Default, false, CancellationToken.None));
}
/// <summary>
/// Writes the specified columns to the table.
/// <br/>
/// Each column must be an object implementing one of the interfaces:
/// <see cref="IReadOnlyList{T}"/>,
/// <see cref="IList{T}"/>,
/// <see cref="IEnumerable{T}"/> or
/// <see cref="IEnumerable"/>.
/// </summary>
/// <param name="columns">The list of columns.</param>
/// <param name="rowCount">The number of rows in columns.</param>
/// <param name="transactionMode">The mode of sending write confirmations to the server.See <see cref="ClickHouseTransactionMode"/> for details.</param>
public void WriteTable(IReadOnlyList<object?> columns, int rowCount, ClickHouseTransactionMode transactionMode)
{
TaskHelper.WaitNonAsyncTask(WriteTable(columns, rowCount, transactionMode, false, CancellationToken.None));
}
/// <summary>
/// Asyncronously writes the specified columns to the table.
/// <br/>
/// Each column must be an object implementing one of the interfaces:
/// <see cref="IReadOnlyList{T}"/>,
/// <see cref="IList{T}"/>,
/// <see cref="IAsyncEnumerable{T}"/>,
/// <see cref="IEnumerable{T}"/> or
/// <see cref="IEnumerable"/>.
/// </summary>
/// <param name="columns">The <see cref="IReadOnlyDictionary{TKey, TValue}"/> object that provides access to columns by their names.</param>
/// <param name="rowCount">The number of rows in columns.</param>
/// <param name="cancellationToken">The cancellation instruction.</param>
/// <returns>A <see cref="Task"/> representing asyncronous operation.</returns>
public async Task WriteTableAsync(IReadOnlyDictionary<string, object?> columns, int rowCount, CancellationToken cancellationToken)
{
await WriteTable(columns, rowCount, ClickHouseTransactionMode.Default, true, cancellationToken);
}
/// <summary>
/// Asyncronously writes the specified columns to the table.
/// <br/>
/// Each column must be an object implementing one of the interfaces:
/// <see cref="IReadOnlyList{T}"/>,
/// <see cref="IList{T}"/>,
/// <see cref="IAsyncEnumerable{T}"/>,
/// <see cref="IEnumerable{T}"/> or
/// <see cref="IEnumerable"/>.
/// </summary>
/// <param name="columns">The <see cref="IReadOnlyDictionary{TKey, TValue}"/> object that provides access to columns by their names.</param>
/// <param name="rowCount">The number of rows in columns.</param>
/// <param name="transactionMode">The mode of sending write confirmations to the server.See <see cref="ClickHouseTransactionMode"/> for details.</param>
/// <param name="cancellationToken">The cancellation instruction.</param>
/// <returns>A <see cref="Task"/> representing asyncronous operation.</returns>
public async Task WriteTableAsync(IReadOnlyDictionary<string, object?> columns, int rowCount, ClickHouseTransactionMode transactionMode, CancellationToken cancellationToken)
{
await WriteTable(columns, rowCount, transactionMode, true, cancellationToken);
}
/// <summary>
/// Asyncronously writes the specified columns to the table.
/// <br/>
/// Each column must be an object implementing one of the interfaces:
/// <see cref="IReadOnlyList{T}"/>,
/// <see cref="IList{T}"/>,
/// <see cref="IAsyncEnumerable{T}"/>,
/// <see cref="IEnumerable{T}"/> or
/// <see cref="IEnumerable"/>.
/// </summary>
/// <param name="columns">The list of columns.</param>
/// <param name="rowCount">The number of rows in columns.</param>
/// <param name="cancellationToken">The cancellation instruction.</param>
/// <returns>A <see cref="Task"/> representing asyncronous operation.</returns>
public async Task WriteTableAsync(IReadOnlyList<object?> columns, int rowCount, CancellationToken cancellationToken)
{
await WriteTable(columns, rowCount, ClickHouseTransactionMode.Default, true, cancellationToken);
}
/// <summary>
/// Asyncronously writes the specified columns to the table.
/// <br/>
/// Each column must be an object implementing one of the interfaces:
/// <see cref="IReadOnlyList{T}"/>,
/// <see cref="IList{T}"/>,
/// <see cref="IAsyncEnumerable{T}"/>,
/// <see cref="IEnumerable{T}"/> or
/// <see cref="IEnumerable"/>.
/// </summary>
/// <param name="columns">The list of columns.</param>
/// <param name="rowCount">The number of rows in columns.</param>
/// <param name="transactionMode">The mode of sending write confirmations to the server.See <see cref="ClickHouseTransactionMode"/> for details.</param>
/// <param name="cancellationToken">The cancellation instruction.</param>
/// <returns>A <see cref="Task"/> representing asyncronous operation.</returns>
public async Task WriteTableAsync(IReadOnlyList<object?> columns, int rowCount, ClickHouseTransactionMode transactionMode, CancellationToken cancellationToken)
{
await WriteTable(columns, rowCount, transactionMode, true, cancellationToken);
}
private async ValueTask WriteTable(IReadOnlyDictionary<string, object?> columns, int rowCount, ClickHouseTransactionMode mode, bool async, CancellationToken cancellationToken)
{
if (columns == null)
throw new ArgumentNullException(nameof(columns));
var list = new List<object?>(_columns.Count);
foreach (var columnInfo in _columns)
{
if (columns.TryGetValue(columnInfo.Name, out var column))
list.Add(column);
else
list.Add(null);
}
await WriteTable(list, rowCount, mode, async, cancellationToken);
}
private async ValueTask WriteTable(IReadOnlyList<object?> columns, int rowCount, ClickHouseTransactionMode mode, bool async, CancellationToken cancellationToken)
{
if (columns == null)
throw new ArgumentNullException(nameof(columns));
if (columns.Count != _columns.Count)
throw new ArgumentException("The number of columns for writing must be equal to the number of columns in the table.", nameof(columns));
if (rowCount < 0)
throw new ArgumentOutOfRangeException(nameof(rowCount));
if (rowCount == 0)
throw new ArgumentException("The number of rows must be greater than zero.", nameof(rowCount));
if (IsClosed)
throw new ClickHouseException(ClickHouseErrorCodes.InvalidConnectionState, "The writer is closed.");
var writerFactories = new List<IClickHouseColumnWriterFactory>(_columns.Count);
for (int i = 0; i < _columns.Count; i++)
{
var factory = await CreateColumnWriterFactory(_columns[i], columns[i], i, rowCount, _columnSettings?[i], async, cancellationToken);
writerFactories.Add(factory);
}
int offset;
var blockSize = MaxBlockSize ?? rowCount;
bool commitBlock = mode == ClickHouseTransactionMode.Block;
for (offset = 0; offset + blockSize < rowCount; offset += blockSize)
{
var table = new ClickHouseTableWriter(string.Empty, blockSize, writerFactories.Select(w => w.Create(offset, blockSize)));
await SendTable(table, commitBlock, async, cancellationToken);
}
var finalBlockSize = rowCount - offset;
var finalTable = new ClickHouseTableWriter(string.Empty, finalBlockSize, writerFactories.Select(w => w.Create(offset, finalBlockSize)));
bool commit = commitBlock || mode == ClickHouseTransactionMode.Default || mode == ClickHouseTransactionMode.Auto;
await SendTable(finalTable, commit, async, cancellationToken);
}
private async ValueTask SendTable(ClickHouseTableWriter table, bool commit, bool async, CancellationToken cancellationToken)
{
if (_endOfStream)
await RepeatQuery(async, cancellationToken);
try
{
await _session.SendTable(table, async, cancellationToken);
if (commit)
await EndWrite(TerminationMode.Confirm, closeSession: false, async, cancellationToken);
}
catch (ClickHouseHandledException)
{
throw;
}
catch (Exception ex)
{
var aggrEx = await _session.SetFailed(ex, false, async);
if (aggrEx != null)
throw aggrEx;
throw;
}
}
private async ValueTask RepeatQuery(bool async, CancellationToken cancellationToken)
{
ClickHouseTable data;
try
{
await _session.SendQuery(_query, async, cancellationToken);
data = await ReadTableMetadata(_session, _query.Query, async, cancellationToken);
_endOfStream = false;
}
catch (ClickHouseServerException)
{
await _session.Dispose(async);
throw;
}
catch (ClickHouseHandledException)
{
await _session.Dispose(async);
throw;
}
catch (Exception ex)
{
var aggrEx = await _session.SetFailed(ex, false, async);
if (aggrEx != null)
throw aggrEx;
throw;
}
try
{
// Repeating the query is almost the same as opening a new independent column writer. So we must check that the structure of the table wasn't changed.
var newColumns = data.Header.Columns;
if (newColumns.Count != _columns.Count)
throw new ClickHouseException(ClickHouseErrorCodes.TableModified, "The number of columns returned by the query has changed.");
for (int i = 0; i < data.Columns.Count; i++)
{
var newCol = newColumns[i];
var origCol = _columns[i];
if (!string.Equals(origCol.Name, newCol.Name, StringComparison.Ordinal))
throw new ClickHouseException(ClickHouseErrorCodes.TableModified, $"Unexpected column \"{newCol.Name}\" at the position {i}. Expected \"{origCol.Name}\".");
if (!string.Equals(origCol.TypeInfo.ComplexTypeName, newCol.TypeInfo.ComplexTypeName, StringComparison.Ordinal))
throw new ClickHouseException(ClickHouseErrorCodes.TableModified, $"The type of the column \"{origCol.Name}\" has changed from \"{origCol.TypeInfo.ComplexTypeName}\" to \"{newCol.TypeInfo.ComplexTypeName}\" between queries.");
}
}
catch (Exception ex)
{
try
{
await EndWrite(TerminationMode.Cancel, closeSession: true, async, cancellationToken);
}
catch (Exception cancellationEx)
{
throw new AggregateException(ex, cancellationEx);
}
var hEx = ClickHouseHandledException.Wrap(ex);
if (ReferenceEquals(hEx, ex))
throw;
throw hEx;
}
}
/// <summary>
/// Notifies the server that the transaction should be commited.
/// This method acts similar to <see cref="EndWrite()"/>, but it doesn't close the writer.
/// </summary>
/// <remarks>A subsequent writing operation will send a new INSERT query to the server.</remarks>
public void Commit()
{
TaskHelper.WaitNonAsyncTask(EndWrite(TerminationMode.Confirm, closeSession: false, async: false, CancellationToken.None));
}
/// <summary>
/// Asyncronously notifies the server that the transaction should be commited.
/// This method acts similar to <see cref="EndWriteAsync(CancellationToken)"/>, but it doesn't close the writer.
/// </summary>
/// <param name="cancellationToken">The cancellation instruction.</param>
/// <returns>A <see cref="Task"/> representing asyncronous operation.</returns>
/// <remarks>A subsequent writing operation will send a new INSERT query to the server.</remarks>
public async Task CommitAsync(CancellationToken cancellationToken)
{
await EndWrite(TerminationMode.Confirm, closeSession: false, async: true, cancellationToken);
}
/// <summary>
/// Closes the writer and releases all resources associated with it.
/// </summary>
public void EndWrite()
{
TaskHelper.WaitNonAsyncTask(EndWrite(TerminationMode.Confirm, closeSession: true, false, CancellationToken.None));
}
/// <summary>
/// Notifies the server that non-commited rows shoud be discarded. This method takes an effect
/// only if the pervious operation was made in the <see cref="ClickHouseTransactionMode.Manual"/> mode.
/// </summary>
public void Rollback()
{
TaskHelper.WaitNonAsyncTask(EndWrite(TerminationMode.Cancel, closeSession: false, async: false, CancellationToken.None));
}
/// <summary>
/// Asyncronously notifies the server that non-commited rows shoud be discarded. This method takes an effect
/// only if the pervious operation was made in the <see cref="ClickHouseTransactionMode.Manual"/> mode.
/// </summary>
/// <param name="cancellationToken">The cancellation instruction.</param>
/// <returns>A <see cref="Task"/> representing asyncronous operation.</returns>
/// <remarks>A subsequent writing operation will send a new INSERT query to the server.</remarks>
public async Task RollbackAsync(CancellationToken cancellationToken)
{
await EndWrite(TerminationMode.Cancel, closeSession: false, async: true, cancellationToken);
}
/// <summary>
/// Asyncronously closes the writer and releases all resources associated with it.
/// </summary>
/// <param name="cancellationToken">The cancellation instruction.</param>
/// <returns>A <see cref="Task"/> representing asyncronous operation.</returns>
public async Task EndWriteAsync(CancellationToken cancellationToken)
{
await EndWrite(TerminationMode.Confirm, closeSession: true, true, cancellationToken);
}
private async ValueTask EndWrite(TerminationMode mode, bool closeSession, bool async, CancellationToken cancellationToken)
{
// If the writer is dispesed the session should also be disposed
Debug.Assert(closeSession || mode != TerminationMode.Dispose);
if (IsClosed)
return;
if (_endOfStream)
{
if (closeSession)
await _session.Dispose(async);
return;
}
try
{
switch (mode)
{
case TerminationMode.None:
break;
case TerminationMode.Cancel:
case TerminationMode.Dispose:
await _session.SendCancel(async);
break;
case TerminationMode.Confirm:
await _session.SendTable(ClickHouseEmptyTableWriter.Instance, async, cancellationToken);
break;
default:
Debug.Fail($"Unexpected termination mode: {mode}.");
break;
}
bool isProfileEvents;
do
{
isProfileEvents = false;
var message = await _session.ReadMessage(async, CancellationToken.None);
switch (message.MessageCode)
{
case ServerMessageCode.EndOfStream:
if (closeSession)
await _session.Dispose(async);
_endOfStream = true;
break;
case ServerMessageCode.Error:
// Connection state can't be resotred if the server raised an exception.
// This error is probably caused by the wrong formatted data.
var exception = ((ServerErrorMessage)message).Exception;
if (mode == TerminationMode.Dispose)
{
await _session.SetFailed(exception, false, async);
break;
}
throw exception;
case ServerMessageCode.ProfileEvents:
isProfileEvents = true;
var profileEventsMessage = (ServerDataMessage)message;
await _session.SkipTable(profileEventsMessage, async, cancellationToken);
break;
case ServerMessageCode.ProfileInfo:
break;
case ServerMessageCode.Progress:
var progressMessage = (ServerProgressMessage)message;
ExecutionProgress = progressMessage.ExecutionProgress;
break;
default:
throw new ClickHouseException(ClickHouseErrorCodes.ProtocolUnexpectedResponse, $"Unexpected server message: \"{message.MessageCode}\".");
}
} while (isProfileEvents);
}
catch (ClickHouseHandledException ex)
{
if (mode != TerminationMode.Dispose)
throw;
// Connection state can't be restored
await _session.SetFailed(ex.InnerException, false, async);
}
catch (Exception ex)
{
var aggrEx = await _session.SetFailed(ex, false, async);
if (aggrEx != null)
throw aggrEx;
throw;
}
}
/// <summary>
/// Closes the writer and releases all resources associated with it.
/// </summary>
public void Dispose()
{
TaskHelper.WaitNonAsyncTask(Dispose(false));
}
/// <summary>
/// Asyncronously closes the writer and releases all resources associated with it.
/// </summary>
/// <returns>A <see cref="ValueTask"/> representing asyncronous operation.</returns>
public ValueTask DisposeAsync()
{
return Dispose(true);
}
private async ValueTask Dispose(bool async)
{
await EndWrite(TerminationMode.Dispose, closeSession: true, async, CancellationToken.None);
}
internal static async ValueTask<IClickHouseColumnWriterFactory> CreateColumnWriterFactory(ColumnInfo columnInfo, object? column, int columnIndex, int rowCount, ClickHouseColumnSettings? settings, bool async, CancellationToken cancellationToken)
{
if (settings?.ColumnType == typeof(object))
{
throw new ClickHouseException(
ClickHouseErrorCodes.InvalidColumnSettings,
$"Type \"{settings.ColumnType}\" should not be used as a type of a column. This type is defined in column settings of the column \"{columnInfo.Name}\" (position {columnIndex}).");
}
if (column == null)
{
if (!columnInfo.TypeInfo.TypeName.StartsWith("Nullable"))
throw new ClickHouseException(ClickHouseErrorCodes.ColumnTypeMismatch, $"The column \"{columnInfo.Name}\" at the position {columnIndex} doesn't support nulls.");
ITypeDispatcher? typeDispatcher;
if (settings?.ColumnType != null)
{
if (settings.ColumnType.IsValueType && Nullable.GetUnderlyingType(settings.ColumnType) == null)
{
throw new ClickHouseException(
ClickHouseErrorCodes.ColumnTypeMismatch,
$"The column \"{columnInfo.Name}\" (position {columnIndex}) contains null value. But the type of this column defined in the settings (\"{settings.ColumnType}\") doesn't allow nulls.");
}
typeDispatcher = settings.GetColumnTypeDispatcher();
Debug.Assert(typeDispatcher != null);
}
else
{
typeDispatcher = TypeDispatcher.Create(columnInfo.TypeInfo.GetFieldType());
}
var constColumn = typeDispatcher.Dispatch(new NullColumnWriterDispatcher(columnInfo, settings, rowCount));
return constColumn;
}
var columnType = column.GetType();
Type? enumerable = null;
Type? altEnumerable = null;
Type? asyncEnumerable = null;
Type? altAsyncEnumerable = null;
Type? readOnlyList = null;
Type? altReadOnlyList = null;
Type? list = null;
Type? altList = null;
foreach (var ifs in columnType.GetInterfaces())
{
if (!ifs.IsGenericType)
continue;
var ifsDefinition = ifs.GetGenericTypeDefinition();
if (ifsDefinition == typeof(IEnumerable<>) && ifs.GetGenericArguments()[0] != typeof(object))
{
altEnumerable ??= enumerable;
enumerable = ifs;
}
else if (ifsDefinition == typeof(IAsyncEnumerable<>) && ifs.GetGenericArguments()[0] != typeof(object))
{
altAsyncEnumerable = asyncEnumerable;
asyncEnumerable = ifs;
}
else if (ifsDefinition == typeof(IReadOnlyList<>) && ifs.GetGenericArguments()[0] != typeof(object))
{
altReadOnlyList = readOnlyList;
readOnlyList = ifs;
}
else if (ifsDefinition == typeof(IList<>) && ifs.GetGenericArguments()[0] != typeof(object))
{
altList = list;
list = ifs;
}
}
/*
* All supported interfaces (sorted by priority):
* 1. IReadOnlyList<T>
* 2. IList<T>
* 3. IAsyncEnumerable<T> (supported only in ascynronuous mode, i.e. async == true)
* 4. IEnumerable<T>
* 5. IEnumerable
*/
var explicitTypeDispatcher = settings?.GetColumnTypeDispatcher();
IClickHouseColumnWriterFactory? columnWriter;
if (explicitTypeDispatcher != null)
{
Debug.Assert(settings?.ColumnType != null);
// The type is explicitly specified in the column settings. Either cast the column to a collection
// of this type or throw an exception.
columnWriter = explicitTypeDispatcher.Dispatch(new ColumnWriterDispatcher(column, columnInfo, settings, rowCount, columnIndex, async));
if (columnWriter != null)
return columnWriter;
if (async && typeof(IAsyncEnumerable<>).MakeGenericType(settings.ColumnType).IsAssignableFrom(columnType))
{
columnWriter = await explicitTypeDispatcher.Dispatch(new AsyncColumnWriterDispatcher(column, columnInfo, settings, rowCount, columnIndex, cancellationToken));
return columnWriter;
}
// There is almost no chance that IEnumerable's IEnumerator returns the value of expected type if at least one of interfaces is implemented by the column's type.
bool ignoreNonGenericEnumerable = readOnlyList != null || list != null || asyncEnumerable != null || enumerable != null;
columnWriter = explicitTypeDispatcher.Dispatch(new ColumnWriterObjectCollectionDispatcher(column, columnInfo, settings, rowCount, columnIndex, async, ignoreNonGenericEnumerable));
if (columnWriter != null)
return columnWriter;
if (async && column is IAsyncEnumerable<object?> aeCol)
{
columnWriter = await explicitTypeDispatcher.Dispatch(new AsyncObjectColumnWriterDispatcher(aeCol, columnInfo, settings, rowCount, columnIndex, cancellationToken));
return columnWriter;
}
if (!async)
{
Type? aeInterface = typeof(IAsyncEnumerable<>).MakeGenericType(settings.ColumnType);
if (!aeInterface.IsAssignableFrom(settings.ColumnType))
{
aeInterface = column is IAsyncEnumerable<object?> ? typeof(IAsyncEnumerable<object?>) : null;
}
if (aeInterface != null)
{
throw new ClickHouseException(
ClickHouseErrorCodes.NotSupportedInSyncronousMode,
$"The column \"{columnInfo.Name}\" at the position {columnIndex} implements interface \"{aeInterface}\". Call async method \"{nameof(WriteTableAsync)}\".");
}
}
throw new ClickHouseException(
ClickHouseErrorCodes.ColumnTypeMismatch,
$"The column \"{columnInfo.Name}\" at the position {columnIndex} is not a collection of type \"{settings.ColumnType}\". This type is defined in the column's settings.");
}
// Trying to extract an actual type of column's items from an interface implemented by this column.
Type dispatchedElementType;
if (readOnlyList != null)
{
if (altReadOnlyList != null)
throw CreateInterfaceAmbiguousException(readOnlyList, altReadOnlyList, columnInfo.Name, columnIndex);
dispatchedElementType = readOnlyList.GetGenericArguments()[0];
}
else if (list != null)
{
if (altList != null)
throw CreateInterfaceAmbiguousException(list, altList, columnInfo.Name, columnIndex);
dispatchedElementType = list.GetGenericArguments()[0];
}
else
{
if (async && asyncEnumerable != null)
{
if (altAsyncEnumerable != null)
throw CreateInterfaceAmbiguousException(asyncEnumerable, altAsyncEnumerable, columnInfo.Name, columnIndex);
var genericArg = asyncEnumerable.GetGenericArguments()[0];
var asyncDispatcher = new AsyncColumnWriterDispatcher(column, columnInfo, settings, rowCount, columnIndex, cancellationToken);
var asyncColumn = await TypeDispatcher.Dispatch(genericArg, asyncDispatcher);
return asyncColumn;
}
if (enumerable != null)
{
if (altEnumerable != null)
throw CreateInterfaceAmbiguousException(enumerable, altEnumerable, columnInfo.Name, columnIndex);
dispatchedElementType = enumerable.GetGenericArguments()[0];
}
else
{
// There is still hope that the column implements one of suported interfaces with typeof(T) == typeof(object).
// In this case assume that the type of the table's field is equal to the type of the column.
dispatchedElementType = columnInfo.TypeInfo.GetFieldType();
var typeDispatcher = TypeDispatcher.Create(dispatchedElementType);
var objDispatcher = new ColumnWriterObjectCollectionDispatcher(column, columnInfo, settings, rowCount, columnIndex, async);
var objColumnWriter = typeDispatcher.Dispatch(objDispatcher);
if (async && objColumnWriter == null && column is IAsyncEnumerable<object?> aeCol)
{
var asyncDispatcher = new AsyncObjectColumnWriterDispatcher(aeCol, columnInfo, settings, rowCount, columnIndex, cancellationToken);
objColumnWriter = await typeDispatcher.Dispatch(asyncDispatcher);
}
if (objColumnWriter == null)
{
if (!async && (asyncEnumerable != null || column is IAsyncEnumerable<object?>))
{
var aeInterface = asyncEnumerable ?? typeof(IAsyncEnumerable<object?>);
throw new ClickHouseException(
ClickHouseErrorCodes.NotSupportedInSyncronousMode,
$"The column \"{columnInfo.Name}\" at the position {columnIndex} implements interface \"{aeInterface}\". Call async method \"{nameof(WriteTableAsync)}\".");
}
throw new ClickHouseException(ClickHouseErrorCodes.ColumnTypeMismatch, $"The column \"{columnInfo.Name}\" at the position {columnIndex} is not a collection.");
}
return objColumnWriter;
}
}
var dispatcher = new ColumnWriterDispatcher(column, columnInfo, settings, rowCount, columnIndex, false);
columnWriter = TypeDispatcher.Dispatch(dispatchedElementType, dispatcher);
if (columnWriter == null)
throw new ClickHouseException(ClickHouseErrorCodes.ColumnTypeMismatch, $"The column \"{columnInfo.Name}\" at the position {columnIndex} is not a collection.");
return columnWriter;
}
private static ClickHouseException CreateInterfaceAmbiguousException(Type itf, Type altItf, string columnName, int columnIndex)
{
return new ClickHouseException(ClickHouseErrorCodes.ColumnTypeMismatch,
$"A type of the column \"{columnName}\" at the position {columnIndex} is ambiguous. The column implements interfaces \"{itf}\" and \"{altItf}\".");
}
private class ColumnWriterFactory<T> : IClickHouseColumnWriterFactory
{
private readonly ColumnInfo _columnInfo;
private readonly IReadOnlyList<T> _rows;
private readonly ClickHouseColumnSettings? _columnSettings;
public ColumnWriterFactory(ColumnInfo columnInfo, IReadOnlyList<T> rows, ClickHouseColumnSettings? columnSettings)
{
_columnInfo = columnInfo;
_rows = rows;
_columnSettings = columnSettings;
}
public IClickHouseColumnWriter Create(int offset, int length)
{
var slice = _rows.Slice(offset, length);
return _columnInfo.TypeInfo.CreateColumnWriter(_columnInfo.Name, slice, _columnSettings);
}
}
private class NullColumnWriterDispatcher : ITypeDispatcher<IClickHouseColumnWriterFactory>
{
private readonly ColumnInfo _columnInfo;
private readonly ClickHouseColumnSettings? _columnSettings;
private readonly int _rowCount;
public NullColumnWriterDispatcher(ColumnInfo columnInfo, ClickHouseColumnSettings? columnSettings, int rowCount)
{
_columnInfo = columnInfo;
_columnSettings = columnSettings;
_rowCount = rowCount;
}
public IClickHouseColumnWriterFactory Dispatch<T>()
{
var rows = new ConstantReadOnlyList<T>(default, _rowCount);
return new ColumnWriterFactory<T>(_columnInfo, rows, _columnSettings);
}
}
private class AsyncColumnWriterDispatcher : ITypeDispatcher<Task<IClickHouseColumnWriterFactory>>
{
private readonly object _asyncEnumerable;
private readonly ColumnInfo _columnInfo;
private readonly ClickHouseColumnSettings? _columnSettings;
private readonly int _rowCount;
private readonly int _columnIndex;
private readonly CancellationToken _cancellationToken;
public AsyncColumnWriterDispatcher(
object asyncEnumerable,
ColumnInfo columnInfo,
ClickHouseColumnSettings? columnSettings,
int rowCount,
int columnIndex,
CancellationToken cancellationToken)
{
_asyncEnumerable = asyncEnumerable;
_columnInfo = columnInfo;
_columnSettings = columnSettings;
_rowCount = rowCount;
_columnIndex = columnIndex;
_cancellationToken = cancellationToken;
}
public async Task<IClickHouseColumnWriterFactory> Dispatch<T>()
{
if (_rowCount == 0)
return new ColumnWriterFactory<T>(_columnInfo, Array.Empty<T>(), _columnSettings);
ConfiguredCancelableAsyncEnumerable<T>.Enumerator enumerator = default;
bool disposeEnumerator = false;
try
{
enumerator = ((IAsyncEnumerable<T>)_asyncEnumerable).WithCancellation(_cancellationToken).GetAsyncEnumerator();
disposeEnumerator = true;
var rows = new T[_rowCount];
for (int i = 0; i < _rowCount; i++)
{
if (!await enumerator.MoveNextAsync())
{
throw new ClickHouseException(
ClickHouseErrorCodes.InvalidRowCount,
$"The column \"{_columnInfo.Name}\" at the position {_columnIndex} has only {i} row(s), but the required number of rows is {_rowCount}.");
}
rows[i] = enumerator.Current;
}
return new ColumnWriterFactory<T>(_columnInfo, rows, _columnSettings);
}
finally
{
if (disposeEnumerator)
await enumerator.DisposeAsync();
}
}
}
private class AsyncObjectColumnWriterDispatcher : ITypeDispatcher<Task<IClickHouseColumnWriterFactory>>
{
private readonly IAsyncEnumerable<object?> _asyncEnumerable;
private readonly ColumnInfo _columnInfo;
private readonly ClickHouseColumnSettings? _columnSettings;
private readonly int _rowCount;
private readonly int _columnIndex;
private readonly CancellationToken _cancellationToken;
public AsyncObjectColumnWriterDispatcher(
IAsyncEnumerable<object?> asyncEnumerable,
ColumnInfo columnInfo,
ClickHouseColumnSettings? columnSettings,
int rowCount,
int columnIndex,
CancellationToken cancellationToken)
{
_asyncEnumerable = asyncEnumerable;
_columnInfo = columnInfo;
_columnSettings = columnSettings;
_rowCount = rowCount;
_columnIndex = columnIndex;
_cancellationToken = cancellationToken;
}
public async Task<IClickHouseColumnWriterFactory> Dispatch<T>()
{
if (_rowCount == 0)
return new ColumnWriterFactory<T>(_columnInfo, Array.Empty<T>(), _columnSettings);
ConfiguredCancelableAsyncEnumerable<object?>.Enumerator enumerator = default;
bool disposeEnumerator = false;
try
{
enumerator = _asyncEnumerable.WithCancellation(_cancellationToken).GetAsyncEnumerator();
disposeEnumerator = true;
var rows = new T[_rowCount];
for (int i = 0; i < _rowCount; i++)
{
if (!await enumerator.MoveNextAsync())
{
throw new ClickHouseException(
ClickHouseErrorCodes.InvalidRowCount,
$"The column \"{_columnInfo.Name}\" at the position {_columnIndex} has only {i} row(s), but the required number of rows is {_rowCount}.");
}
rows[i] = ColumnWriterObjectCollectionDispatcher.CastTo<T>(enumerator.Current);
}
return new ColumnWriterFactory<T>(_columnInfo, rows, _columnSettings);
}
finally
{
if (disposeEnumerator)
await enumerator.DisposeAsync();
}
}
}
private class ColumnWriterDispatcher : ITypeDispatcher<IClickHouseColumnWriterFactory?>
{
private readonly object _collection;
private readonly ColumnInfo _columnInfo;
private readonly ClickHouseColumnSettings? _columnSettings;
private readonly int _rowCount;
private readonly int _columnIndex;
private readonly bool _checkAsyncEnumerable;
public ColumnWriterDispatcher(
object collection,
ColumnInfo columnInfo,
ClickHouseColumnSettings? columnSettings,
int rowCount,
int columnIndex,
bool checkAsyncEnumerable)
{
_collection = collection;
_columnInfo = columnInfo;
_columnSettings = columnSettings;
_rowCount = rowCount;
_columnIndex = columnIndex;
_checkAsyncEnumerable = checkAsyncEnumerable;
}
public IClickHouseColumnWriterFactory? Dispatch<T>()
{
if (_collection is IReadOnlyList<T> readOnlyList)
{
if (readOnlyList.Count < _rowCount)
{
throw new ClickHouseException(
ClickHouseErrorCodes.InvalidRowCount,
$"The column \"{_columnInfo.Name}\" at the position {_columnIndex} has only {readOnlyList.Count} row(s), but the required number of rows is {_rowCount}.");
}
if (readOnlyList.Count > _rowCount)
readOnlyList = readOnlyList.Slice(0, _rowCount);
return new ColumnWriterFactory<T>(_columnInfo, readOnlyList, _columnSettings);
}
if (_collection is IList<T> list)
{
if (list.Count < _rowCount)
{
throw new ClickHouseException(
ClickHouseErrorCodes.InvalidRowCount,
$"The column \"{_columnInfo.Name}\" at the position {_columnIndex} has only {list.Count} row(s), but the required number of rows is {_rowCount}.");
}
var listSpan = list.Slice(0, _rowCount);
return new ColumnWriterFactory<T>(_columnInfo, listSpan, _columnSettings);
}
if (_checkAsyncEnumerable && _collection is IAsyncEnumerable<T>)
{
// Should be handled in async mode
return null;
}
if (_collection is IEnumerable<T> genericEnumerable)
{
using var enumerator = genericEnumerable.GetEnumerator();
T[] rows = new T[_rowCount];
for (int i = 0; i < _rowCount; i++)
{
if (!enumerator.MoveNext())
{
throw new ClickHouseException(
ClickHouseErrorCodes.InvalidRowCount,
$"The column \"{_columnInfo.Name}\" at the position {_columnIndex} has only {i} row(s), but the required number of rows is {_rowCount}.");
}
rows[i] = enumerator.Current;
}
return new ColumnWriterFactory<T>(_columnInfo, rows, _columnSettings);
}
return null;
}
}
private class ColumnWriterObjectCollectionDispatcher : ITypeDispatcher<IClickHouseColumnWriterFactory?>
{
private readonly object _collection;
private readonly ColumnInfo _columnInfo;
private readonly ClickHouseColumnSettings? _columnSettings;
private readonly int _rowCount;
private readonly int _columnIndex;
private readonly bool _checkAsyncEnumerable;
private readonly bool _ignoreNonGenericEnumerable;
public ColumnWriterObjectCollectionDispatcher(
object collection,
ColumnInfo columnInfo,
ClickHouseColumnSettings? columnSettings,
int rowCount,
int columnIndex,
bool checkAsyncEnumerable,
bool ignoreNonGenericEnumerable = false)
{
_collection = collection;
_columnInfo = columnInfo;
_columnSettings = columnSettings;
_rowCount = rowCount;
_columnIndex = columnIndex;
_checkAsyncEnumerable = checkAsyncEnumerable;
_ignoreNonGenericEnumerable = ignoreNonGenericEnumerable;
}
public IClickHouseColumnWriterFactory? Dispatch<T>()
{
if (_collection is IReadOnlyList<object?> readOnlyList)
{
if (readOnlyList.Count < _rowCount)
{
throw new ClickHouseException(
ClickHouseErrorCodes.InvalidRowCount,
$"The column \"{_columnInfo.Name}\" at the position {_columnIndex} has only {readOnlyList.Count} row(s), but the required number of rows is {_rowCount}.");
}
if (readOnlyList.Count > _rowCount)
readOnlyList = readOnlyList.Slice(0, _rowCount);
}
else if (_collection is IList<object?> list)
{
if (list.Count < _rowCount)
{
throw new ClickHouseException(
ClickHouseErrorCodes.InvalidRowCount,
$"The column \"{_columnInfo.Name}\" at the position {_columnIndex} has only {list.Count} row(s), but the required number of rows is {_rowCount}.");
}
readOnlyList = list.Slice(0, _rowCount);
}
else if (_checkAsyncEnumerable && _collection is IAsyncEnumerable<object?>)
{
// Should be handled in async mode
return null;
}
else if (_collection is IEnumerable<object?> genericEnumerable)
{
using var enumerator = genericEnumerable.GetEnumerator();
T[] rows = new T[_rowCount];
for (int i = 0; i < _rowCount; i++)
{
if (!enumerator.MoveNext())
{
throw new ClickHouseException(
ClickHouseErrorCodes.InvalidRowCount,
$"The column \"{_columnInfo.Name}\" at the position {_columnIndex} has only {i} row(s), but the required number of rows is {_rowCount}.");
}
rows[i] = CastTo<T>(enumerator.Current);
}
return new ColumnWriterFactory<T>(_columnInfo, rows, _columnSettings);
}
else if (!_ignoreNonGenericEnumerable && _collection is IEnumerable enumerable)
{
IEnumerator? enumerator = null;
try
{
enumerator = enumerable.GetEnumerator();
T[] rows = new T[_rowCount];
for (int i = 0; i < _rowCount; i++)
{
if (!enumerator.MoveNext())
{
throw new ClickHouseException(
ClickHouseErrorCodes.InvalidRowCount,
$"The column \"{_columnInfo.Name}\" at the position {_columnIndex} has only {i} row(s), but the required number of rows is {_rowCount}.");
}
rows[i] = CastTo<T>(enumerator.Current);
}
return new ColumnWriterFactory<T>(_columnInfo, rows, _columnSettings);
}
finally
{
(enumerator as IDisposable)?.Dispose();
}
}
else
{
// An object is not a collection
return null;
}
var mappedList = readOnlyList.Map(CastTo<T>);
return new ColumnWriterFactory<T>(_columnInfo, mappedList, _columnSettings);
}
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static T CastTo<T>(object? value)
{
// T may be nullable but there is no way to declare T?
if (value == DBNull.Value)
return (T)(default(T) is null ? null! : value);
return (T)value!;
}
}
private class SingleRowColumnWriterDispatcher : ITypeDispatcher<IClickHouseColumnWriter>
{
[AllowNull] private readonly object _value;
private readonly ColumnInfo _columnInfo;
private readonly ClickHouseColumnSettings? _columnSettings;
public SingleRowColumnWriterDispatcher(object? value, ColumnInfo columnInfo, ClickHouseColumnSettings? columnSettings)
{
_value = value;
_columnInfo = columnInfo;
_columnSettings = columnSettings;
}
public IClickHouseColumnWriter Dispatch<T>()
{
var rows = new ConstantReadOnlyList<T>((T) _value, 1);
return _columnInfo.TypeInfo.CreateColumnWriter(_columnInfo.Name, rows, _columnSettings);
}
}
private enum TerminationMode
{
/// <summary>
/// Send nothing and wait for EndOfStream
/// </summary>
None = 0,
/// <summary>
/// Send Cancel and wait for EndOfStream
/// </summary>
Cancel = 1,
/// <summary>
/// Send confirmation message (completely empty talbe) and wait for EndOfStream
/// </summary>
Confirm = 2,
/// <summary>
/// Send Cancel and then release all resources associated with the writer
/// </summary>
Dispose = 3
}
}
}
================================================
FILE: src/Octonica.ClickHouseClient/ClickHouseCommand.cs
================================================
#region License Apache 2.0
/* Copyright 2019-2026 Octonica
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#endregion
using System;
using System.Collections.Generic;
using System.Data;
using System.Data.Common;
using System.Diagnostics.CodeAnalysis;
using System.Globalization;
using System.Linq;
using System.Text;
using System.Text.RegularExpressions;
using System.Threading;
using System.Threading.Tasks;
using Octonica.ClickHouseClient.Exceptions;
using Octonica.ClickHouseClient.Protocol;
using Octonica.ClickHouseClient.Types;
using Octonica.ClickHouseClient.Utils;
namespace Octonica.ClickHouseClient
{
/// <summary>
/// Represents an SQL statement to execute against a ClickHouse database. This class cannot be inherited.
/// </summary>
public sealed class ClickHouseCommand : DbCommand
{
private string? _commandText;
private TimeSpan? _commandTimeout;
/// <summary>
/// Gets or sets the SQL statement to execute at the data source.
/// </summary>
[AllowNull]
public override string CommandText
{
get => _commandText ?? string.Empty;
set => _commandText = value;
}
/// <summary>
/// Gets or sets the wait time (in seconds) before terminating the attempt to execute a command and generating an error.
/// </summary>
public override int CommandTimeout
{
get => (int)CommandTimeoutSpan.TotalSeconds;
set => CommandTimeoutSpan = TimeSpan.FromSeconds(value);
}
/// <summary>
/// Gets or sets the wait time before terminating the attempt to execute a command and generating an error.
/// </summary>
public TimeSpan CommandTimeoutSpan
{
get => GetCommandTimeout(Connection);
set => _commandTimeout = value;
}
/// <summary>
/// Gets the sets type of the command. The only supported type is <see cref="CommandType.Text"/>.
/// </summary>
/// <returns>The value <see cref="CommandType.Text"/>.</returns>
/// <exception cref="NotSupportedException">The type set is not <see cref="CommandType.Text"/>.</exception>
public override CommandType CommandType
{
get => CommandType.Text;
set
{
if (value != CommandType.Text)
throw new NotSupportedException($"The type of the command \"{value}\" is not supported.");
}
}
/// <summary>
/// Gets or sets how command results are applied to the <see cref="DataRow"/> when used by the Update method of the <see cref="DbDataAdapter"/>.
/// The value of this property is ignored by the command and therefore doesn't affect it's behavior.
/// </summary>
/// <returns>One of enumeration values that indicates how command results are applied. The default value is <see cref="UpdateRowSource.None"/>.</returns>
public override UpdateRowSource UpdatedRowSource { get; set; }
/// <summary>
/// Gets or sets the <see cref="ClickHouseConnection"/> used by this command.
/// </summary>
public new ClickHouseConnection? Connection { get; set; }
/// <inheritdoc cref="Connection"/>
protected override DbConnection? DbConnection
{
get => Connection;
set => Connection = (ClickHouseConnection?) value;
}
/// <summary>
/// Gets the <see cref="ClickHouseParameterCollection"/>.
/// </summary>
/// <returns>The parameters of the SQL statement. The default is an empty collection.</returns>
public new ClickHouseParameterCollection Parameters { get; } = new ClickHouseParameterCollection();
/// <inheritdoc cref="Parameters"/>
protected sealed override DbParameterCollection DbParameterCollection => Parameters;
/// <summary>
/// Gets the <see cref="ClickHouseTableProviderCollection"/>.
/// </summary>
/// <returns>
/// The tables which should be sent along with the query. The default is an empty collection.
/// </returns>
public ClickHouseTableProviderCollection TableProviders { get; } = new ClickHouseTableProviderCollection();
/// <summary>
/// Gets or sets the transaction within which the command executes. Always returns <b>null</b>.
/// </summary>
/// <returns><b>null</b></returns>
/// <exception cref="NotSupportedException">The value set is not <b>null</b>.</exception>
protected override DbTransaction? DbTransaction
{
get => null;
set
{
if (value != null)
throw new NotSupportedException($"{nameof(DbTransaction)} is read only.'");
}
}
/// <summary>
/// Gets or sets a value indicating whether the command object should be visible in a customized interface control.
/// </summary>
/// <returns><see langword="true"/>, if the command object should be visible in a control; otherwise <see langword="false"/>. The default is <see langword="true"/>.</returns>
public override bool DesignTimeVisible { get; set; } = true;
/// <summary>
/// Gets or sets value indicating whether the query should be executed with an explicitly defined values of the property 'extremes'.
/// </summary>
public bool? Extremes { get; set; }
/// <summary>
/// Gets or sets a value indicating whether profile events should be ignored while reading data.
/// </summary>
/// <returns><see langword="true"/>, if the data reader should skip profile events. <see langword="false"/>,
/// if the data reader should return profile events as a recordset. The default value is <see langword="true"/>.</returns>
public bool IgnoreProfileEvents { get; set; } = true;
/// <summary>
/// Gets or sets the mode of passing parameters to the query. The value of this property overrides <see cref="ClickHouseConnection.ParametersMode"/>.
/// </summary>
/// <returns>The mode of passing parameters to the query. The default value is <see cref="ClickHouseParameterMode.Inherit"/>.</returns>
public ClickHouseParameterMode ParametersMode { get; set; } = ClickHouseParameterMode.Inherit;
/// <summary>
/// Optional. Gets or sets the identifier passed along with the query as the query ID.
/// Usually, a query identifier is generated by the sever, setting it on the client side is not required.
/// </summary>
public string? QueryId { get; set; }
/// <summary>
/// Creates a new instance of <see cref="ClickHouseCommand"/>.
/// </summary>
public ClickHouseCommand()
{
}
internal ClickHouseCommand(ClickHouseConnection connection)
{
Connection = connection ?? throw new ArgumentNullException(nameof(connection));
}
/// <summary>
/// Not supported. To cancel a command execute it asyncronously with an appropriate cancellation token.
/// </summary>
/// <exception cref="NotImplementedException">Always throws <see cref="NotImplementedException"/>.</exception>
public override void Cancel()
{
throw new NotImplementedException();
}
/// <summary>
/// Executes a SQL statement against a connection object.
/// </summary>
/// <returns>The number of rows affected. The returned value is negative when the actual number of rows is greater than <see cref="int.MaxValue"/>.</returns>
public override int ExecuteNonQuery()
{
var result = TaskHelper.WaitNonAsyncTask(ExecuteNonQuery(false, CancellationToken.None));
if (result > int.MaxValue)
return int.MinValue;
return (int) result;
}
/// <summary>
/// Executes a SQL statement against a connection object asyncronously.
/// </summary>
/// <param name="cancellationToken"></param>
/// <returns>
/// A <see cref="Task{TResult}"/> representing the asynchronous operation. The result (<see cref="Task{TResult}.Result"/>) is the
/// number of affected rows. The result is negative when the actual number of rows is greater than <see cref="int.MaxValue"/>.
/// </returns>
public override async Task<int> ExecuteNonQueryAsync(CancellationToken cancellationToken)
{
var result = await ExecuteNonQuery(true, cancellationToken);
if (result > int.MaxValue)
return int.MinValue;
return (int) result;
}
private async ValueTask<ulong> ExecuteNonQuery(bool async, CancellationToken cancellationToken)
{
ClickHouseTcpClient.Session? session = null;
bool cancelOnFailure = false;
try
{
session = await OpenSession(false, async, cancellationToken);
var query = await SendQuery(session, CommandBehavior.Default, async, cancellationToken);
cancelOnFailure = true;
(ulong read, ulong written) result = (0, 0), progress = (0, 0);
while (true)
{
var message = await session.ReadMessage(async, cancellationToken);
switch (message.MessageCode)
{
case ServerMessageCode.Data:
case ServerMessageCode.Totals:
case ServerMessageCode.Extremes:
var dataMessage = (ServerDataMessage) message;
var blockHeader = await session.SkipTable(dataMessage, async, cancellationToken);
if (blockHeader.Columns.Count == 0 && blockHeader.RowCount == 0)
{
result = (result.read + progress.read, result.written + progress.written);
progress = (0, 0);
}
continue;
case ServerMessageCode.ProfileEvents:
var profileEventsMessage = (ServerDataMessage)message;
await session.SkipTable(profileEventsMessage, async, cancellationToken);
continue;
case ServerMessageCode.Error:
throw ((ServerErrorMessage) message).Exception.CopyWithQuery(query);
case ServerMessageCode.EndOfStream:
result = (result.read + progress.read, result.written + progress.written);
await session.Dispose(async);
if (result.written > 0)
{
// INSERT command could also return the number of parsed rows. Return only the number of inserted rows.
return result.written;
}
return result.read;
case ServerMessageCode.Progress:
var progressMessage = (ServerProgressMessage) message;
progress = (progressMessage.ExecutionProgress.Rows, progressMessage.ExecutionProgress.WrittenRows);
continue;
case ServerMessageCode.ProfileInfo:
continue;
case ServerMessageCode.Pong:
case ServerMessageCode.Hello:
case ServerMessageCode.Log:
throw new ClickHouseException(ClickHouseErrorCodes.ProtocolUnexpectedResponse, $"Unexpected server message: \"{message.MessageCode}\".");
default:
throw new NotSupportedException($"Internal error. Message code \"{message.MessageCode}\" not supported.");
}
}
}
catch (ClickHouseHandledException ex)
{
// Exception can't be handled at this level
if (session != null)
{
var aggrEx = await session.SetFailed(ex.InnerException, cancelOnFailure, async);
if (aggrEx != null)
throw aggrEx;
}
throw;
}
catch (Exception ex)
{
if (session != null)
{
var aggrEx = await session.SetFailed(ex, cancelOnFailure, async);
if (aggrEx != null)
throw aggrEx;
}
throw;
}
finally
{
if (session != null)
await session.Dispose(async);
}
}
/// <summary>
/// Executes the query and returns the first column of the first row in the result set returned by the query.
/// All other columns and rows are ignored.
/// </summary>
/// <returns>
/// The first row of the first columns in the result set or <see cref="DBNull.Value"/> if the result set is empty.
/// </returns>
public override object ExecuteScalar()
{
return TaskHelper.WaitNonAsyncTask(ExecuteScalar(null, false, CancellationToken.None));
}
/// <summary>
/// Executes the query and returns the first column of the first row in the result set returned by the query.
/// All other columns and rows are ignored.
/// </summary>
/// <param name="columnSettings">Optional parameter. Settings for the first column in the result set.</param>
/// <returns>
/// The first row of the first columns in the result set or <see cref="DBNull.Value"/> if the result set is empty.
/// </returns>
public object ExecuteScalar(ClickHouseColumnSettings? columnSettings)
{
return TaskHelper.WaitNonAsyncTask(ExecuteScalar(columnSettings, false, CancellationToken.None));
}
/// <summary>
/// Executes the query and returns the first column of the first row in the result set returned by the query.
/// All other columns and rows are ignored.
/// </summary>
/// <typeparam name="T">The expected type of the first column in the result set.</typeparam>
/// <returns>
/// The first row of the first columns in the result set.
/// </returns>
public T ExecuteScalar<T>()
{
return TaskHelper.WaitNonAsyncTask(ExecuteScalar<T>(null, false, CancellationToken.None));
}
/// <summary>
/// Executes the query and returns the first column of the first row in the result set returned by the query.
/// All other columns and rows are ignored.
/// </summary>
/// <typeparam name="T">The expected type of the first column in the result set.</typeparam>
/// <param name="columnSettings">Optional parameter. Settings for the first column in the result set.</param>
/// <returns>
/// The first row of the first columns in the result set.
/// </returns>
public T ExecuteScalar<T>(ClickHouseColumnSettings? columnSettings)
{
return TaskHelper.WaitNonAsyncTask(ExecuteScalar<T>(columnSettings, false, CancellationToken.None));
}
/// <summary>
/// Executes the query asyncronously and returns the first column of the first row in the result set returned by the query.
/// All other columns and rows are ignored.
/// </summary>
/// <param name="cancellationToken">The cancellation instruction.</param>
/// <returns>
/// A <see cref="Task{TResult}"/> representing the asynchronous operation. The result (<see cref="Task{TResult}.Result"/>) is
/// the first row of the first columns in the result set or <see cref="DBNull.Value"/> if the result set is empty.
/// </returns>
public override async Task<object?> ExecuteScalarAsync(CancellationToken cancellationToken)
{
return await ExecuteScalar(null, true, cancellationToken);
}
/// <summary>
/// Executes the query asyncronously and returns the first column of the first row in the result set returned by the query.
/// All other columns and rows are ignored.
/// </summary>
/// <param name="columnSettings">Optional parameter. Settings for the first column in the result set.</param>
/// <returns>
/// A <see cref="Task{TResult}"/> representing the asynchronous operation. The result (<see cref="Task{TResult}.Result"/>) is
/// the first row of the first columns in the result set or <see cref="DBNull.Value"/> if the result set is empty.
/// </returns>
public async Task<object> ExecuteScalarAsync(ClickHouseColumnSettings? columnSettings)
{
return await ExecuteScalar(columnSettings, true, CancellationToken.None);
}
/// <summary>
/// Executes the query asyncronously and returns the first column of the first row in the result set returned by the query.
/// All other columns and rows are ignored.
/// </summary>
/// <param name="columnSettings">Optional parameter. Settings for the first column in the result set.</param>
/// <param name="cancellationToken">The cancellation instruction.</param>
/// <returns>
/// A <see cref="Task{TResult}"/> representing the asynchronous operation. The result (<see cref="Task{TResult}.Result"/>) is
/// the first row of the first columns in the result set or <see cref="DBNull.Value"/> if the result set is empty.
/// </returns>
public async Task<object> ExecuteScalarAsync(ClickHouseColumnSettings? columnSettings, CancellationToken cancellationToken)
{
return await ExecuteScalar(columnSettings, true, cancellationToken);
}
/// <summary>
/// Executes the query asyncronously and returns the first column of the first row in the result set returned by the query.
/// All other columns and rows are ignored.
/// </summary>
/// <typeparam name="T">The expected type of the first column in the result set.</typeparam>
/// <returns>
/// A <see cref="Task{TResult}"/> representing the asynchronous operation. The result (<see cref="Task{TResult}.Result"/>) is
/// the first row of the first columns in the result set.
/// </returns>
public async Task<T> ExecuteScalarAsync<T>()
{
return await ExecuteScalar<T>(null, true, CancellationToken.None);
}
/// <summary>
/// Executes the query asyncronously and returns the first column of the first row in the result set returned by the query.
/// All other columns and rows are ignored.
/// </summary>
/// <typeparam name="T">The expected type of the first column in the result set.</typeparam>
/// <param name="cancellationToken">The cancellation instruction.</param>
/// <returns>
/// A <see cref="Task{TResult}"/> representing the asynchronous operation. The result (<see cref="Task{TResult}.Result"/>) is
/// the first row of the first columns in the result set.
/// </returns>
public async Task<T> ExecuteScalarAsync<T>(CancellationToken cancellationToken)
{
return await ExecuteScalar<T>(null, true, cancellationToken);
}
/// <summary>
/// Executes the query asyncronously and returns the first column of the first row in the result set returned by the query.
/// All other columns and rows are ignored.
/// </summary>
/// <typeparam name="T">The expected type of the first column in the result set.</typeparam>
/// <param name="columnSettings">Optional parameter. Settings for the first column in the result set.</param>
/// <returns>
/// A <see cref="Task{TResult}"/> representing the asynchronous operation. The result (<see cref="Task{TResult}.Result"/>) is
/// the first row of the first columns in the result set.
/// </returns>
public async Task<T> ExecuteScalarAsync<T>(ClickHouseColumnSettings? columnSettings)
{
return await ExecuteScalar<T>(columnSettings, true, CancellationToken.None);
}
/// <summary>
/// Executes the query asyncronously and returns the first column of the first row in the result set returned by the query.
/// All other columns and rows are ignored.
/// </summary>
/// <typeparam name="T">The expected type of the first column in the result set.</typeparam>
/// <param name="columnSettings">Optional parameter. Settings for the first column in the result set.</param>
/// <param name="cancellationToken">The cancellation instruction.</param>
/// <returns>
/// A <see cref="Task{TResult}"/> representing the asynchronous operation. The result (<see cref="Task{TResult}.Result"/>) is
/// the first row of the first columns in the result set.
/// </returns>
public async Task<T> ExecuteScalarAsync<T>(ClickHouseColumnSettings? columnSettings, CancellationToken cancellationToken)
{
return await ExecuteScalar<T>(columnSettings, true, cancellationToken);
}
private async ValueTask<T> ExecuteScalar<T>(ClickHouseColumnSettings? columnSettings, bool async, CancellationToken cancellationToken)
{
var result = await ExecuteScalar(columnSettings, reader => reader.GetFieldValue<T>(0), async, cancellationToken);
return (T) result;
}
private ValueTask<object> ExecuteScalar(ClickHouseColumnSettings? columnSettings, bool async, CancellationToken cancellationToken)
{
return ExecuteScalar(columnSettings, reader => reader.GetValue(0), async, cancellationToken);
}
private async ValueTask<object> ExecuteScalar(ClickHouseColumnSettings? columnSettings, Func<ClickHouseDataReader, object?> valueSelector, bool async, CancellationToken cancellationToken)
{
ClickHouseDataReader? reader = null;
try
{
reader = await ExecuteDbDataReader(CommandBehavior.Default, true, async, cancellationToken);
bool hasAnyColumn = reader.FieldCount > 0;
if (!hasAnyColumn)
return DBNull.Value;
if (columnSettings != null)
reader.ConfigureColumn(0, columnSettings);
bool hasAnyRow = async ? await reader.ReadAsync(cancellationToken) : reader.Read();
if (!hasAnyRow)
return DBNull.Value;
if (reader.IsDBNull(0))
return DBNull.Value;
var result = valueSelector(reader);
if (async)
await reader.CloseAsync();
else
reader.Close();
return result ?? DBNull.Value;
}
finally
{
if (async)
{
if (reader != null)
await reader.DisposeAsync();
}
else
{
reader?.Dispose();
}
}
}
/// <summary>
/// Not supported. A preparation of the command is not implemented.
/// </summary>
/// <exception cref="NotImplementedException">Always throws <see cref="NotImplementedException"/>.</exception>
public override void Prepare()
{
throw new NotImplementedException();
}
/// <inheritdoc cref="Prepare"/>
public override Task PrepareAsync(CancellationToken cancellationToken = new CancellationToken())
{
throw new NotImplementedException();
}
/// <summary>
/// Creates a new <see cref="ClickHouseParameter"/> object with the default name and adds it to the collection of parameters (<see cref="Parameters"/>).
/// </summary>
/// <returns>A new <see cref="ClickHouseParameter"/> object.</returns>
protected override DbParameter CreateDbParameter()
{
const string baseParamName = "param";
int i = 0;
string paramName;
do
{
paramName = string.Format(CultureInfo.InvariantCulture, "{{{0}{1}}}", baseParamName, ++i);
} while (Parameters.Contains(paramName));
return new ClickHouseParameter(paramName);
}
/// <summary>
/// Executes the query asyncronously and builds a <see cref="ClickHouseDataReader"/> with the default command behavior.
/// </summary>
/// <returns>A <see cref="Task{TResult}"/> representing the asynchronous operation.</returns>
public new async Task<ClickHouseDataReader> ExecuteReaderAsync()
{
return await ExecuteDbDataReader(CommandBehavior.Default, IgnoreProfileEvents, true, CancellationToken.None);
}
/// <summary>
/// Executes the query asyncronously and builds a <see cref="ClickHouseDataReader"/> with the default command behavior.
/// </summary>
/// <param name="cancellationToken">The cancellation instruction.</param>
/// <returns>A <see cref="Task{TResult}"/> representing the asynchronous operation.</returns>
public new async Task<ClickHouseDataReader> ExecuteReaderAsync(CancellationToken cancellationToken)
{
return await ExecuteDbDataReader(CommandBehavior.Default, IgnoreProfileEvents, true, cancellationToken);
}
/// <summary>
/// Executes the query asyncronously and builds a <see cref="ClickHouseDataReader"/>.
/// </summary>
/// <param name="behavior">
/// The set of flags determining the behavior of the command.
/// The flag <see cref="CommandBehavior.KeyInfo"/> is not supported.
/// The flag <see cref="CommandBehavior.SequentialAccess"/> is ignored.
/// </param>
/// <returns>A <see cref="Task{TResult}"/> representing the asynchronous operation.</returns>
public new async Task<ClickHouseDataReader> ExecuteReaderAsync(CommandBehavior behavior)
{
return await ExecuteDbDataReader(behavior, IgnoreProfileEvents, true, CancellationToken.None);
}
/// <summary>
/// Executes the query asyncronously and builds a <see cref="ClickHouseDataReader"/>.
/// </summary>
/// <param name="behavior">
/// The set of flags determining the behavior of the command.
/// The flag <see cref="CommandBehavior.KeyInfo"/> is not supported.
/// The flag <see cref="CommandBehavior.SequentialAccess"/> is ignored.
/// </param>
/// <param name="cancellationToken">The cancellation instruction.</param>
/// <returns>A <see cref="Task{TResult}"/> representing the asynchronous operation.</returns>
public new async Task<ClickHouseDataReader> ExecuteReaderAsync(CommandBehavior behavior, CancellationToken cancellationToken)
{
return await ExecuteDbDataReader(behavior, IgnoreProfileEvents, true, cancellationToken);
}
/// <inheritdoc cref="ExecuteReaderAsync(CommandBehavior, CancellationToken)"/>
protected override async Task<DbDataReader> ExecuteDbDataReaderAsync(CommandBehavior behavior, CancellationToken cancellationToken)
{
return await ExecuteDbDataReader(behavior, IgnoreProfileEvents, true, cancellationToken);
}
/// <summary>
/// Executes the query and builds a <see cref="ClickHouseDataReader"/> with the default command behavior.
/// </summary>
/// <returns>A <see cref="ClickHouseDataReader"/> object.</returns>
public new ClickHouseDataReader ExecuteReader()
{
return TaskHelper.WaitNonAsyncTask(ExecuteDbDataReader(CommandBehavior.Default, IgnoreProfileEvents, false, CancellationToken.None));
}
/// <summary>
/// Executes the query and builds a <see cref="ClickHouseDataReader"/>.
/// </summary>
/// <param name="behavior">
/// The set of flags determining the behavior of the command.
/// The flag <see cref="CommandBehavior.KeyInfo"/> is not supported.
/// The flag <see cref="CommandBehavior.SequentialAccess"/> is ignored.
/// </param>
/// <returns>A <see cref="ClickHouseDataReader"/> object.</returns>
public new ClickHouseDataReader ExecuteReader(CommandBehavior behavior)
{
return TaskHelper.WaitNonAsyncTask(ExecuteDbDataReader(behavior, IgnoreProfileEvents, false, CancellationToken.None));
}
/// <inheritdoc cref="ExecuteReader(CommandBehavior)"/>
protected override DbDataReader ExecuteDbDataReader(CommandBehavior behavior)
{
return TaskHelper.WaitNonAsyncTask(ExecuteDbDataReader(behavior, IgnoreProfileEvents, false, CancellationToken.None));
}
private async ValueTask<ClickHouseDataReader> ExecuteDbDataReader(CommandBehavior behavior, bool ignoreProfileEvents, bool async, CancellationToken cancellationToken)
{
const CommandBehavior knownBehaviorFlags =
CommandBehavior.CloseConnection |
CommandBehavior.KeyInfo |
CommandBehavior.SchemaOnly |
CommandBehavior.SequentialAccess |
CommandBehavior.SingleResult |
CommandBehavior.SingleRow;
var unknownBehaviorFlags = behavior & ~knownBehaviorFlags;
if (unknownBehaviorFlags != 0)
throw new ArgumentException($"Command behavior has unknown flags ({unknownBehaviorFlags}).", nameof(behavior));
if (behavior.HasFlag(CommandBehavior.KeyInfo))
{
throw new ArgumentException(
$"Command behavior has unsupported flag {nameof(CommandBehavior.KeyInfo)}." + Environment.NewLine +
"Please, report an issue if you have any idea of how this flag should affect the result (https://github.com/Octonica/ClickHouseClient/issues).",
nameof(behavior));
}
ClickHouseDataReaderRowLimit rowLimit;
if (behavior.HasFlag(CommandBehavior.SchemaOnly))
{
if (behavior.HasFlag(CommandBehavior.SingleRow))
throw new ArgumentException($"Command behavior's flags {nameof(CommandBehavior.SchemaOnly)} and {nameof(CommandBehavior.SingleRow)} are mutualy exclusive.", nameof(behavior));
rowLimit = ClickHouseDataReaderRowLimit.Zero;
}
else if (behavior.HasFlag(CommandBehavior.SingleRow))
{
rowLimit = ClickHouseDataReaderRowLimit.OneRow;
}
else if (behavior.HasFlag(CommandBehavior.SingleResult))
{
rowLimit = ClickHouseDataReaderRowLimit.OneResult;
}
else
{
rowLimit = ClickHouseDataReaderRowLimit.Infinite;
}
ClickHouseTcpClient.Session? session = null;
bool cancelOnFailure = false;
try
{
session = await OpenSession(behavior.HasFlag(CommandBehavior.CloseConnection), async, cancellationToken);
var query = await SendQuery(session, behavior, async, cancellationToken);
cancelOnFailure = true;
bool isProfileEvents;
IServerMessage message;
var executionProgress = new ClickHouseQueryExecutionProgress();
do
{
isProfileEvents = false;
message = await session.ReadMessage(async, cancellationToken);
switch (message.MessageCode)
{
case ServerMessageCode.Data:
break;
case ServerMessageCode.Error:
throw ((ServerErrorMessage)message).Exception.CopyWithQuery(query);
case ServerMessageCode.ProfileEvents:
isProfileEvents = true;
var dataMessage = (ServerDataMessage)message;
await session.SkipTable(dataMessage, async, CancellationToken.None);
break;
case ServerMessageCode.EndOfStream:
// The query was executed without errors but returned no data. Highly likely it was a DDL query. Closing the session.
await session.Dispose(async);
return new ClickHouseDataReader(session);
case ServerMessageCode.Progress:
var progressMessage = (ServerProgressMessage)message;
executionProgress = progressMessage.ExecutionProgress;
break;
case ServerMessageCode.ProfileInfo:
case ServerMessageCode.Pong:
continue;
case ServerMessageCode.Totals:
case ServerMessageCode.Extremes:
throw new ClickHouseException(ClickHouseErrorCodes.ProtocolUnexpectedResponse, "Received unexpected totals or extremes before the main dataset.");
default:
throw new ClickHouseException(ClickHouseErrorCodes.QueryTypeMismatch, "There is no table in the server's response.");
}
}
while (!(message is ServerDataMessage) || isProfileEvents);
var firstTable = await session.ReadTable((ServerDataMessage) message, null, async, cancellationToken);
if (rowLimit == ClickHouseDataReaderRowLimit.Zero)
await session.SendCancel(async);
return new ClickHouseDataReader(firstTable, session, executionProgress, rowLimit, ignoreProfileEvents);
}
catch (ClickHouseHandledException)
{
if (session != null)
await session.Dispose(async);
throw;
}
catch (ClickHouseServerException)
{
if (session != null)
await session.Dispose(async);
throw;
}
catch (Exception ex)
{
Exception? aggrEx = null;
if (session != null)
aggrEx = await session.SetFailed(ex, cancelOnFailure, async);
if (aggrEx != null)
throw aggrEx;
throw;
}
}
private async ValueTask<string> SendQuery(ClickHouseTcpClient.Session session, CommandBehavior behavior, bool async, CancellationToken cancellationToken)
{
string commandText;
List<IClickHouseTableWriter>? tableWriters = null;
Dictionary<string, ClickHouseParameterWriter>? parameterWriters;
try
{
var parametersTable = $"_{Guid.NewGuid():N}";
commandText = PrepareCommandText(session.TypeInfoProvider, parametersTable, out var binaryParameters, out parameterWriters);
if (binaryParameters != null && binaryParameters.Count > 0)
{
var paramTableWriter = CreateParameterTableWriter(session.TypeInfoProvider, parametersTable, binaryParameters);
tableWriters = new List<IClickHouseTableWriter>(TableProviders.Count + 1) { paramTableWriter };
}
if (TableProviders.Count > 0)
{
tableWriters ??= new List<IClickHouseTableWriter>(TableProviders.Count);
foreach (var tableProvider in TableProviders)
{
if (tableProvider.ColumnCount == 0)
continue;
var tableWriter = await CreateTableWriter(tableProvider, session.TypeInfoProvider, async, cancellationToken);
tableWriters.Add(tableWriter);
}
}
}
catch (Exception ex)
{
throw ClickHouseHandledException.Wrap(ex);
}
List<KeyValuePair<string, string>>? setting = null;
if (Extremes != null)
{
setting = new List<KeyValuePair<string, string>>(1) {new KeyValuePair<string, string>("extremes", Extremes.Value ? "1" : "0")};
}
if (session.ServerInfo.Revision >= ClickHouseProtocolRevisions.MinRevisionWithSettingsSerializedAsStrings)
{
if (behavior.HasFlag(CommandBehavior.SchemaOnly) || behavior.HasFlag(CommandBehavior.SingleRow))
{
// https://github.com/ClickHouse/ClickHouse/blob/master/src/Core/Settings.h
// This settings are hints for the server. The result may contain more than one row.
setting ??= new List<KeyValuePair<string, string>>(2);
setting.Add(new KeyValuePair<string, string>("max_result_rows", "1"));
setting.Add(new KeyValuePair<string, string>("result_overflow_mode", "break"));
}
}
var messageBuilder = new ClientQueryMessage.Builder { QueryKind = QueryKind.InitialQuery, QueryId = QueryId, Query = commandText, Settings = setting, Parameters = parameterWriters };
await session.SendQuery(messageBuilder, tableWriters, async, cancellationToken);
return commandText;
}
private async ValueTask<ClickHouseTcpClient.Session> OpenSession(bool closeConnection, bool async, CancellationToken cancellationToken)
{
var connection = Connection;
if (connection == null)
throw new InvalidOperationException("The connection is not set. The command can't be executed without a connection.");
SessionResources? resources = null;
try
{
var timeout = GetCommandTimeout(connection);
CancellationTokenSource? sessionTokenSource = null;
if (timeout > TimeSpan.Zero)
sessionTokenSource = new CancellationTokenSource(timeout);
if (closeConnection || sessionTokenSource != null)
resources = new SessionResources(closeConnection ? connection : null, sessionTokenSource);
return await connection.OpenSession(async, resources, sessionTokenSource?.Token ?? CancellationToken.None, cancellationToken);
}
catch
{
if (resources != null)
await resources.Release(async);
throw;
}
}
private TimeSpan GetCommandTimeout(ClickHouseConnection? connection)
{
return _commandTimeout ?? connection?.CommandTimeSpan ?? TimeSpan.FromSeconds(ClickHouseConnectionStringBuilder.DefaultCommandTimeout);
}
private ClickHouseParameterMode GetParametersMode(ClickHouseConnection? connection)
{
var mode = ParametersMode;
if (mode != ClickHouseParameterMode.Inherit)
return mode;
return connection?.ParametersMode ?? ClickHouseParameterMode.Default;
}
private IClickHouseTableWriter CreateParameterTableWriter(IClickHouseTypeInfoProvider typeInfoProvider, string tableName, HashSet<string> parameters)
{
return new ClickHouseTableWriter(tableName, 1, Parameters.Where(p => parameters.Contains(p.Id)).Select(p => p.CreateParameterColumnWriter(typeInfoProvider)));
}
private static async ValueTask<IClickHouseTableWriter> CreateTableWriter(IClickHouseTableProvider tableProvider, IClickHouseTypeInfoProvider typeInfoProvider, bool async, CancellationToken cancellationToken)
{
var factories = new List<IClickHouseColumnWriterFactory>(tableProvider.ColumnCount);
var rowCount = tableProvider.RowCount;
for (int i = 0; i < tableProvider.ColumnCount; i++)
{
var columnDescriptor = tableProvider.GetColumnDescriptor(i);
var typeInfo = typeInfoProvider.GetTypeInfo(columnDescriptor);
var columnInfo = new ColumnInfo(columnDescriptor.ColumnName, typeInfo);
var column = tableProvider.GetColumn(i);
var factory = await ClickHouseColumnWriter.CreateColumnWriterFactory(columnInfo, column, i, rowCount, columnDescriptor.Settings, async, cancellationToken);
factories.Add(factory);
}
return new ClickHouseTableWriter(tableProvider.TableName, rowCount, factories.Select(f => f.Create(0, rowCount)));
}
private string PrepareCommandText(IClickHouseTypeInfoProvider typeInfoProvider, string parametersTable, out HashSet<string>? binaryParameters, out Dictionary<string, ClickHouseParameterWriter>? parameterWriters)
{
var query = CommandText;
if (string.IsNullOrEmpty(query))
throw new InvalidOperationException("Command text is not defined.");
var parameterPositions = GetParameterPositions(query);
binaryParameters = null;
parameterWriters = null;
if (parameterPositions.Count == 0)
return query;
var inheritParameterMode = GetParametersMode(Connection);
var queryStringBuilder = new StringBuilder(query.Length);
for (int i = 0; i < parameterPositions.Count; i++)
{
var (offset, length, typeSeparatorIdx) = parameterPositions[i];
var start = i > 0 ? parameterPositions[i - 1].offset + parameterPositions[i - 1].length : 0;
queryStringBuilder.Append(query, start, parameterPositions[i].offset - start);
var parameterName = typeSeparatorIdx < 0 ? query.Substring(offset, length) : query.Substring(offset + 1, typeSeparatorIdx - 1);
if (!Parameters.TryGetValue(parameterName, out var parameter))
throw new ClickHouseException(ClickHouseErrorCodes.QueryParameterNotFound, $"Parameter \"{parameterName}\" not found.");
if (typeSeparatorIdx >= 0)
queryStringBuilder.Append("(CAST(");
var parameterMode = parameter.GetParameterMode(inheritParameterMode);
switch (parameterMode)
{
case ClickHouseParameterMode.Interpolate:
{
var parameterWriter = parameter.CreateParameterWriter(typeInfoProvider);
parameterWriter.Interpolate(queryStringBuilder.Append(' ')).Append(' ');
break;
}
case ClickHouseParameterMode.Default:
case ClickHouseParameterMode.Binary:
binaryParameters ??= new HashSet<string>(StringComparer.OrdinalIgnoreCase);
binaryParameters.Add(parameter.Id);
queryStringBuilder.Append("(SELECT ").Append(parametersTable).Append('.').Append(parameter.Id).Append(" FROM ").Append(parametersTable).Append(')');
break;
case ClickHouseParameterMode.Serialize:
{
parameterWriters ??= new Dictionary<string, ClickHouseParameterWriter>(StringComparer.OrdinalIgnoreCase);
if (!parameterWriters.TryGetValue(parameter.Id, out var parameterWriter))
{
parameterWriter = parameter.CreateParameterWriter(typeInfoProvider);
parameterWriters.Add(parameter.Id, parameterWriter);
}
parameterWriter.Interpolate(
queryStringBuilder,
typeInfoProvider,
(qb, tp) => qb.Append('{').Append(parameter.Id).Append(':').Append(tp.ComplexTypeName).Append('}'));
break;
}
default:
throw new ClickHouseException(ClickHouseErrorCodes.InternalError, $"Internal error. Unexpected parameter mode: {parameterMode}.");
}
if (typeSeparatorIdx >= 0)
queryStringBuilder.Append(" AS ").Append(query, offset + typeSeparatorIdx + 1, length - typeSeparatorIdx - 2).Append("))");
}
var lastPartStart = parameterPositions[^1].offset + parameterPositions[^1].length;
queryStringBuilder.Append(query, lastPartStart, query.Length - lastPartStart);
return queryStringBuilder.ToString();
}
private static List<(int offset, int length, int typeSeparatorIdx)> GetParameterPositions(string query)
{
// Searching parameters outside
gitextract_vv1_tqul/
├── .gitignore
├── CHANGELOG.md
├── LICENSE
├── README.md
├── docs/
│ ├── ClickHouseColumnWriter.md
│ ├── Parameters.md
│ └── TypeMapping.md
└── src/
├── ConnectionSettingsHelper.cs
├── Octonica.ClickHouseClient/
│ ├── ClickHouseBinaryProtocolReader.cs
│ ├── ClickHouseBinaryProtocolWriter.cs
│ ├── ClickHouseColumnSettings.cs
│ ├── ClickHouseColumnWriter.cs
│ ├── ClickHouseCommand.cs
│ ├── ClickHouseConnection.cs
│ ├── ClickHouseConnectionSettings.cs
│ ├── ClickHouseConnectionState.cs
│ ├── ClickHouseConnectionStringBuilder.cs
│ ├── ClickHouseDataReader.cs
│ ├── ClickHouseDataReaderBase.cs
│ ├── ClickHouseDataReaderRowLimit.cs
│ ├── ClickHouseDataReaderState.cs
│ ├── ClickHouseDbProviderFactory.cs
│ ├── ClickHouseDbType.cs
│ ├── ClickHouseFlushMode.cs
│ ├── ClickHouseParameter.cs
│ ├── ClickHouseParameterCollection.cs
│ ├── ClickHouseParameterMode.cs
│ ├── ClickHousePasswordComplexityRule.cs
│ ├── ClickHouseQueryExecutionProgress.cs
│ ├── ClickHouseReaderColumnSettings.cs
│ ├── ClickHouseServerInfo.cs
│ ├── ClickHouseTable.cs
│ ├── ClickHouseTableColumn.cs
│ ├── ClickHouseTableColumnCollection.cs
│ ├── ClickHouseTableProvider.cs
│ ├── ClickHouseTableProviderCollection.cs
│ ├── ClickHouseTableWriter.cs
│ ├── ClickHouseTcpClient.cs
│ ├── ClickHouseTcpClientState.cs
│ ├── ClickHouseTlsMode.cs
│ ├── ClickHouseVersion.cs
│ ├── Exceptions/
│ │ ├── ClickHouseErrorCodes.cs
│ │ ├── ClickHouseException.cs
│ │ ├── ClickHouseHandledException.cs
│ │ └── ClickHouseServerException.cs
│ ├── IClickHouseArrayTableColumn.cs
│ ├── IClickHouseColumnDescriptor.cs
│ ├── IClickHouseSessionExternalResources.cs
│ ├── IClickHouseTableColumn.cs
│ ├── IClickHouseTableColumnDispatcher.cs
│ ├── IClickHouseTableProvider.cs
│ ├── Octonica.ClickHouseClient.csproj
│ ├── Properties/
│ │ └── AssemblyInfo.cs
│ ├── Protocol/
│ │ ├── BlockFieldCodes.cs
│ │ ├── BlockHeader.cs
│ │ ├── CityHash.cs
│ │ ├── ClickHouseEmptyTableWriter.cs
│ │ ├── ClickHouseParameterWriter.cs
│ │ ├── ClickHouseProtocolRevisions.cs
│ │ ├── ClickHouseSyntaxHelper.cs
│ │ ├── ClientHelloMessage.cs
│ │ ├── ClientMessageCode.cs
│ │ ├── ClientQueryMessage.cs
│ │ ├── ColumnInfo.cs
│ │ ├── CompressionAlgorithm.cs
│ │ ├── CompressionDecoderBase.cs
│ │ ├── CompressionEncoderBase.cs
│ │ ├── IClickHouseColumnReader.cs
│ │ ├── IClickHouseColumnReaderBase.cs
│ │ ├── IClickHouseColumnWriter.cs
│ │ ├── IClickHouseColumnWriterFactory.cs
│ │ ├── IClickHouseParameterValueWriter.cs
│ │ ├── IClickHouseParameterWriter.cs
│ │ ├── IClickHouseTableWriter.cs
│ │ ├── IClientMessage.cs
│ │ ├── IServerMessage.cs
│ │ ├── Lz4CompressionDecoder.cs
│ │ ├── Lz4CompressionEncoder.cs
│ │ ├── QueryKind.cs
│ │ ├── SequenceSize.cs
│ │ ├── ServerDataMessage.cs
│ │ ├── ServerEndOfStreamMessage.cs
│ │ ├── ServerErrorMessage.cs
│ │ ├── ServerHelloMessage.cs
│ │ ├── ServerMessageCode.cs
│ │ ├── ServerPongMessage.cs
│ │ ├── ServerProfileInfoMessage.cs
│ │ ├── ServerProgressMessage.cs
│ │ ├── ServerTableColumnsMessage.cs
│ │ ├── ServerTimeZoneUpdateMessage.cs
│ │ ├── StateCodes.cs
│ │ └── UnknownServerMessage.cs
│ ├── Types/
│ │ ├── ArrayTableColumn.cs
│ │ ├── ArrayTypeInfo.cs
│ │ ├── BigIntegerTableColumn.cs
│ │ ├── BigIntegerTypeInfoBase.cs
│ │ ├── BoolTableColumn.cs
│ │ ├── BoolTypeInfo.cs
│ │ ├── ClickHouseColumnReinterpreter.cs
│ │ ├── ClickHouseColumnSerializationMode.cs
│ │ ├── ClickHouseEnumConverter.cs
│ │ ├── ClickHouseTableColumnHelper.cs
│ │ ├── ClickHouseTypeInfoProvider.cs
│ │ ├── CustomSerializationColumnReader.cs
│ │ ├── CustomSerializationSkippingColumnReader.cs
│ │ ├── Date32TableColumn.Net6.0.cs
│ │ ├── Date32TableColumn.NetCoreApp3.1.cs
│ │ ├── Date32TableColumn.cs
│ │ ├── Date32TypeInfo.Net6.0.cs
│ │ ├── Date32TypeInfo.NetCoreApp3.1.cs
│ │ ├── Date32TypeInfo.cs
│ │ ├── DateOnlyTableColumn.cs
│ │ ├── DateTime64TableColumn.cs
│ │ ├── DateTime64TypeInfo.cs
│ │ ├── DateTimeTableColumn.cs
│ │ ├── DateTimeTypeInfo.cs
│ │ ├── DateTypeInfo.Net6.0.cs
│ │ ├── DateTypeInfo.NetCoreApp3.1.cs
│ │ ├── DateTypeInfo.cs
│ │ ├── Decimal128TypeInfo.cs
│ │ ├── Decimal32TypeInfo.cs
│ │ ├── Decimal64TypeInfo.cs
│ │ ├── DecimalTableColumn.cs
│ │ ├── DecimalTypeInfo.cs
│ │ ├── DecimalTypeInfoBase.cs
│ │ ├── EmptyParameterValueWriter.cs
│ │ ├── Enum16TypeInfo.cs
│ │ ├── Enum8TypeInfo.cs
│ │ ├── EnumTableColumn.cs
│ │ ├── EnumTypeInfoBase.cs
│ │ ├── FixedStringDecodedCharArrayTableColumn.cs
│ │ ├── FixedStringDecodedTableColumn.cs
│ │ ├── FixedStringTableColumn.cs
│ │ ├── FixedStringTableColumnBase.cs
│ │ ├── FixedStringTypeInfo.cs
│ │ ├── Float32TableColumn.cs
│ │ ├── Float32TypeInfo.cs
│ │ ├── Float64TypeInfo.cs
│ │ ├── HexStringLiteralValueWriter.cs
│ │ ├── HexStringLiteralWriterCastMode.cs
│ │ ├── HexStringParameterWriter.cs
│ │ ├── IClickHouseColumnReinterpreter.cs
│ │ ├── IClickHouseColumnTypeDescriptor.cs
│ │ ├── IClickHouseColumnTypeInfo.cs
│ │ ├── IClickHouseConfigurableTypeInfo.cs
│ │ ├── IClickHouseEnumConverter.cs
│ │ ├── IClickHouseReinterpretedTableColumn.cs
│ │ ├── IClickHouseTypeInfo.cs
│ │ ├── IClickHouseTypeInfoProvider.cs
│ │ ├── Int128TypeInfo.cs
│ │ ├── Int16TableColumn.cs
│ │ ├── Int16TypeInfo.cs
│ │ ├── Int256TypeInfo.cs
│ │ ├── Int32TableColumn.cs
│ │ ├── Int32TypeInfo.cs
│ │ ├── Int64TypeInfo.cs
│ │ ├── Int8TableColumn.cs
│ │ ├── Int8TypeInfo.cs
│ │ ├── IntermediateClickHouseTypeInfo.cs
│ │ ├── IpColumnReaderBase.cs
│ │ ├── IpV4TableColumn.cs
│ │ ├── IpV4TypeInfo.cs
│ │ ├── IpV6TableColumn.cs
│ │ ├── IpV6TypeInfo.cs
│ │ ├── KeyValuePairTableColumn.cs
│ │ ├── LowCardinalityTableColumn.cs
│ │ ├── LowCardinalityTypeInfo.cs
│ │ ├── MapTypeInfo.cs
│ │ ├── NothingTableColumn.cs
│ │ ├── NothingTypeInfo.cs
│ │ ├── NullableTableColumn.cs
│ │ ├── NullableTypeInfo.cs
│ │ ├── ObjectColumnAdapter.cs
│ │ ├── ReinterpretedArrayTableColumn.cs
│ │ ├── ReinterpretedObjectTableColumn.cs
│ │ ├── ReinterpretedTableColumn.cs
│ │ ├── SimpleLiteralValueWriter.cs
│ │ ├── SimpleParameterWriter.cs
│ │ ├── SimpleSkippingColumnReader.cs
│ │ ├── SimpleTypeInfo.cs
│ │ ├── SparseColumn.cs
│ │ ├── StringByteArrayTableColumn.cs
│ │ ├── StringCharArrayTableColumn.cs
│ │ ├── StringLiteralValueWriter.cs
│ │ ├── StringParameterWriter.cs
│ │ ├── StringTableColumn.cs
│ │ ├── StringTableColumnBase.cs
│ │ ├── StringTypeInfo.cs
│ │ ├── StructureReaderBase.cs
│ │ ├── StructureTableColumn.cs
│ │ ├── StructureWriterBase.cs
│ │ ├── TupleTableColumn.cs
│ │ ├── TupleTypeInfo.cs
│ │ ├── UInt128TypeInfo.cs
│ │ ├── UInt16TableColumn.cs
│ │ ├── UInt16TypeInfo.cs
│ │ ├── UInt256TypeInfo.cs
│ │ ├── UInt32TableColumn.cs
│ │ ├── UInt32TypeInfo.cs
│ │ ├── UInt64TypeInfo.cs
│ │ ├── UInt8TableColumn.cs
│ │ ├── UInt8TypeInfo.cs
│ │ ├── UuidTypeInfo.cs
│ │ ├── VariantTableColumn.cs
│ │ └── VariantTypeInfo.cs
│ └── Utils/
│ ├── CertificateHelper.Net5.0.cs
│ ├── CertificateHelper.NetCoreApp3.1.cs
│ ├── CertificateHelper.cs
│ ├── CommonUtils.cs
│ ├── ConstantReadOnlyList.cs
│ ├── FunctionHelper.cs
│ ├── ICollectionList.cs
│ ├── IConverter.cs
│ ├── IConverterDispatcher.cs
│ ├── IReadOnlyListExt.cs
│ ├── ITypeDispatcher.cs
│ ├── IndexedCollectionBase.cs
│ ├── ListExtensions.cs
│ ├── ListSpan.cs
│ ├── MappedListSpan.cs
│ ├── MappedReadOnlyList.cs
│ ├── MappedReadOnlyListSpan.cs
│ ├── MemoryCollectionList.cs
│ ├── MultiDimensionalArrayReadOnlyListAdapter.cs
│ ├── ReadOnlyCollectionList.cs
│ ├── ReadOnlyListSpan.cs
│ ├── ReadOnlyMemoryCollectionList.cs
│ ├── ReadOnlyMemoryList.cs
│ ├── ReadWriteBuffer.cs
│ ├── SimpleReadOnlySequenceSegment.cs
│ ├── TaskHelper.cs
│ ├── TimeZoneHelper.Net6.0.cs
│ ├── TimeZoneHelper.NetCoreApp3.1.cs
│ ├── TimeZoneHelper.cs
│ └── TypeDispatcher.cs
├── Octonica.ClickHouseClient.Benchmarks/
│ ├── ColumnWriterBenchmarks.cs
│ ├── InsertRowBenchmark.cs
│ ├── Octonica.ClickHouseClient.Benchmarks.csproj
│ └── Program.cs
├── Octonica.ClickHouseClient.Tests/
│ ├── AsyncTestFibSequence.cs
│ ├── CityHashTests.Data.cs
│ ├── CityHashTests.cs
│ ├── ClickHouseColumnWriterTests.cs
│ ├── ClickHouseCommandTests.cs
│ ├── ClickHouseConnectionStringBuilderTests.cs
│ ├── ClickHouseConnectionTests.cs
│ ├── ClickHouseDataReaderTests.cs
│ ├── ClickHouseDbProviderFactoryTests.cs
│ ├── ClickHouseParameterCollectionTests.cs
│ ├── ClickHouseParameterTests.cs
│ ├── ClickHouseTestsBase.cs
│ ├── ClickHouseTypeInfoTests.cs
│ ├── CommonUtilsTests.cs
│ ├── EncodingFixture.cs
│ ├── IndexedCollectionTests.cs
│ ├── ListExtensionsTests.cs
│ ├── Octonica.ClickHouseClient.Tests.csproj
│ ├── ReadWriteBufferTests.cs
│ ├── TestBox.cs
│ ├── TestEnum.cs
│ ├── TestIndexedCollection.cs
│ ├── TestListWrappers.cs
│ ├── TypeTests.cs
│ └── xunit.runner.json
└── Octonica.ClickHouseClient.sln
Showing preview only (493K chars total). Download the full file or copy to clipboard to get everything.
SYMBOL INDEX (2612 symbols across 252 files)
FILE: src/ConnectionSettingsHelper.cs
class ConnectionSettingsHelper (line 23) | internal static class ConnectionSettingsHelper
method GetConnectionSettings (line 25) | public static ClickHouseConnectionSettings GetConnectionSettings(Actio...
method GetConnectionString (line 30) | public static string GetConnectionString()
method GetConnectionString (line 35) | public static string GetConnectionString(Action<ClickHouseConnectionSt...
method GetConnectionSettingsInternal (line 42) | private static (ClickHouseConnectionSettings settings, string connecti...
FILE: src/Octonica.ClickHouseClient.Benchmarks/ColumnWriterBenchmarks.cs
class ColumnWriterBenchmarks (line 26) | public class ColumnWriterBenchmarks
method Setup (line 41) | [GlobalSetup]
method WriteBatсhes (line 76) | [Benchmark]
FILE: src/Octonica.ClickHouseClient.Benchmarks/InsertRowBenchmark.cs
class InsertRowBenchmark (line 26) | public class InsertRowBenchmark
method Setup (line 41) | [GlobalSetup]
method InsertWithColumnWriter (line 76) | [Benchmark]
method InsertFromSelect (line 134) | [Benchmark]
FILE: src/Octonica.ClickHouseClient.Benchmarks/Program.cs
class Program (line 22) | internal static class Program
method Main (line 24) | private static void Main()
FILE: src/Octonica.ClickHouseClient.Tests/AsyncTestFibSequence.cs
class AsyncTestFibSequence (line 24) | internal sealed class AsyncTestFibSequence : IAsyncEnumerable<decimal>
method GetAsyncEnumerator (line 26) | public IAsyncEnumerator<decimal> GetAsyncEnumerator(CancellationToken ...
class Enumerator (line 31) | private sealed class Enumerator : IAsyncEnumerator<decimal>
method DisposeAsync (line 38) | public ValueTask DisposeAsync()
method MoveNextAsync (line 43) | public ValueTask<bool> MoveNextAsync()
FILE: src/Octonica.ClickHouseClient.Tests/CityHashTests.Data.cs
class CityHashTests (line 22) | partial class CityHashTests
FILE: src/Octonica.ClickHouseClient.Tests/CityHashTests.cs
class CityHashTests (line 30) | public partial class CityHashTests
method setup (line 42) | void setup()
method C (line 59) | private static UInt64 C(UInt64 v)
method Test (line 64) | void Test(int index, int offset, int len)
method main (line 81) | [Fact]
FILE: src/Octonica.ClickHouseClient.Tests/ClickHouseColumnWriterTests.cs
class ClickHouseColumnWriterTests (line 33) | public class ClickHouseColumnWriterTests : ClickHouseTestsBase, IClassFi...
method ClickHouseColumnWriterTests (line 39) | public ClickHouseColumnWriterTests(TableFixture tableFixture)
method InsertValues (line 44) | [Fact]
method InsertValuesFromGeneratedColumns (line 90) | [Fact]
method InsertValuesFromAsyncEnumerableColumn (line 148) | [Fact]
method InsertStringsWithEncoding (line 197) | [Fact]
method InsertSingleRow (line 239) | [Fact]
method InsertArrayValues (line 290) | [Fact]
method InsertTupleValues (line 377) | [Fact]
method InsertLowCardinalityValues (line 498) | [Fact]
method InsertEnumValues (line 554) | [Fact]
method InsertNullableEnumValues (line 605) | [Fact]
method InsertLargeTable (line 656) | [Theory]
method InsertFromSecondaryInterfaces (line 703) | [Fact]
method InsertValuesWithLowRowCount (line 747) | [Fact]
method InsertArrayFromMemory (line 790) | [Fact]
method InsertStringFromMemory (line 857) | [Fact]
method InsertFixedStringFromMemory (line 951) | [Fact]
method InsertFromCollectionOfObjects (line 1028) | [Fact]
method InsertValuesOfSpecifiedType (line 1083) | [Fact]
method InsertValuesFromObjectArrays (line 1131) | [Fact]
method InsertMapValues (line 1193) | [Fact]
method InsertArrayLowCardinality (line 1253) | [Fact]
method InsertBoolValues (line 1288) | [Fact]
method TransactionModeBlock (line 1350) | [Fact]
method TransactionModeManual (line 1382) | [Fact]
method TransactionModeAuto (line 1424) | [Theory]
method InsertMapLowCardinalityValues (line 1465) | [Fact]
method TransactionModeAutoBackwardCompatibility (line 1503) | [Fact]
method InsertIPv6Values (line 1543) | [Fact]
method InsertEmptyArrayLowCardinality (line 1574) | [Fact]
method InsertVariant (line 1611) | [Fact]
method GetTempTableName (line 1649) | protected override string GetTempTableName(string tableNameSuffix)
class TableFixture (line 1654) | public class TableFixture : ClickHouseTestsBase, IDisposable
method TableFixture (line 1658) | public TableFixture()
method ReserveRange (line 1674) | public int ReserveRange(int length)
method Dispose (line 1690) | public void Dispose()
FILE: src/Octonica.ClickHouseClient.Tests/ClickHouseCommandTests.cs
class ClickHouseCommandTests (line 33) | public class ClickHouseCommandTests : ClickHouseTestsBase
method SimpleExecuteScalar (line 35) | [Fact]
method ExecuteNonQuery (line 46) | [Fact]
method Params (line 64) | [Theory]
method MsSqlLikeParams (line 105) | [Theory]
method EmptyStringParam (line 146) | [Theory]
method TypedParams (line 167) | [Theory]
method UseConnectionInParallel (line 189) | [Fact]
method ReadScalarFromLargeResultSet (line 205) | [Fact]
method UseCommandInParallel (line 224) | [Fact]
method CancelOnSocketTimeout (line 236) | [Fact]
method CancelOnCommandTimeout (line 254) | [Fact]
method CancelOnTokenTimeout (line 267) | [Fact]
method ShouldUnwrapCommandExecuteScalar (line 281) | [Fact]
method ExecuteScalarShouldReturnSingleResult (line 288) | [Fact]
method CommandBehaviorCloseConnection (line 299) | [Fact]
method TableParameterSingleColumn (line 371) | [Fact]
method TableParameterAndScalarParameter (line 395) | [Theory]
method MultipleTableParameters (line 422) | [Theory]
method InsertWithParameters (line 475) | [Fact]
method DeleteWithParameters (line 509) | [Fact]
method UpdateWithParameters (line 539) | [Fact]
method SelectWithOffsetLimitParameters (line 570) | [Fact]
method CreateTableWithCommentParameter (line 590) | [Fact]
method WithQueryId (line 621) | [Fact]
FILE: src/Octonica.ClickHouseClient.Tests/ClickHouseConnectionStringBuilderTests.cs
class ClickHouseConnectionStringBuilderTests (line 23) | public class ClickHouseConnectionStringBuilderTests
method FromString (line 25) | [Fact]
method Remove (line 45) | [Fact]
method SetConnectionString (line 63) | [Fact]
method Default (line 75) | [Fact]
method Clone (line 143) | [Fact]
method InvalidConnectionString (line 222) | [Fact]
method ValidConnectionStringWithInvalidProperty (line 228) | [Fact]
FILE: src/Octonica.ClickHouseClient.Tests/ClickHouseConnectionTests.cs
class ClickHouseConnectionTests (line 30) | public class ClickHouseConnectionTests : ClickHouseTestsBase
method Probe (line 32) | [Fact]
method ShouldUnwrapConnectionOpenExceptions (line 42) | [Fact]
method CanConnectWithUserAndPassword (line 51) | [Fact]
method TryPing (line 71) | [Fact]
method OpenConnectionInParallel (line 122) | [Fact]
method HandleCallbackException (line 177) | [Theory]
method HandleDoubleCallbackException (line 207) | [Fact]
method DisposeCallback (line 233) | [Fact]
FILE: src/Octonica.ClickHouseClient.Tests/ClickHouseDataReaderTests.cs
class ClickHouseDataReaderTests (line 30) | public class ClickHouseDataReaderTests : ClickHouseTestsBase
method SimpleReader (line 32) | [Fact]
method CloseReaderWithoutReading (line 49) | [Fact]
method TotalsWithNextResult (line 85) | [Fact]
method ExtremesWithNextResult (line 119) | [Fact]
method TotalsAndExtremes (line 166) | [Fact]
method SkipNextResult (line 229) | [Theory]
method CommandBehaviorSchemaOnly (line 274) | [Fact]
method CommandBehaviorSingleRow (line 290) | [Fact]
method CommandBehaviorSingleResult (line 307) | [Fact]
method CommandBehaviorSequentialAccess (line 329) | [Fact]
method CommandBehaviorKeyInfo (line 347) | [Fact]
method ProfileEvents (line 358) | [Fact (Skip = "This test is flaky. The server doesn't always respond w...
method DateTimeKindForDate (line 428) | [Fact]
method DateTimeKindForDate32 (line 450) | [Fact]
method SparseSerializedColumns (line 472) | [Fact]
method CustomColumnCast (line 534) | [Fact]
method CustomNullableColumnCast (line 556) | [Fact]
method CustomObjecctColumnCast (line 610) | [Fact]
method ValidColumnReconfiguration (line 630) | [Fact]
method NullableObjectColumnReconfiguration (line 655) | [Fact]
method InavlidColumnReconfiguration (line 709) | [Fact]
method ExecuteDdlQuery (line 748) | [Fact]
method ExecuteCreateInsertFromSelect (line 765) | [Fact]
FILE: src/Octonica.ClickHouseClient.Tests/ClickHouseDbProviderFactoryTests.cs
class ClickHouseDbProviderFactoryTests (line 24) | public class ClickHouseDbProviderFactoryTests
method SupportedFeatures (line 28) | [Fact]
method CreateCommand (line 52) | [Theory]
FILE: src/Octonica.ClickHouseClient.Tests/ClickHouseParameterCollectionTests.cs
class ClickHouseParameterCollectionTests (line 25) | public class ClickHouseParameterCollectionTests
method AddParameter (line 27) | [Fact]
method ChangeParameterName (line 51) | [Fact]
method RemoveParameter (line 82) | [Fact]
method InsertParameter (line 138) | [Fact]
method ReplaceParameter (line 176) | [Fact]
FILE: src/Octonica.ClickHouseClient.Tests/ClickHouseParameterTests.cs
class ClickHouseParameterTests (line 31) | public class ClickHouseParameterTests
method ClickHouseParameterTests (line 35) | static ClickHouseParameterTests()
method Clone (line 50) | [Fact]
method CopyTo (line 99) | [Fact]
method NotSupportedProperties (line 125) | [Fact]
method TypeDetection (line 145) | [Fact]
method AssertParametersEqual (line 201) | private static void AssertParametersEqual(ClickHouseParameter expected...
class PropertyComparerDispatcher (line 212) | private class PropertyComparerDispatcher : ITypeDispatcher<Action<Clic...
method PropertyComparerDispatcher (line 216) | public PropertyComparerDispatcher(PropertyInfo propertyInfo)
method Dispatch (line 221) | public Action<ClickHouseParameter, ClickHouseParameter> Dispatch<T>()
FILE: src/Octonica.ClickHouseClient.Tests/ClickHouseTestsBase.cs
class ClickHouseTestsBase (line 25) | public abstract class ClickHouseTestsBase
method GetDefaultConnectionSettings (line 36) | public ClickHouseConnectionSettings GetDefaultConnectionSettings(Actio...
method OpenConnectionAsync (line 47) | public async Task<ClickHouseConnection> OpenConnectionAsync(ClickHouse...
method OpenConnectionAsync (line 55) | public Task<ClickHouseConnection> OpenConnectionAsync(ClickHouseParame...
method OpenConnectionAsync (line 60) | public async Task<ClickHouseConnection> OpenConnectionAsync(Action<Cli...
method OpenConnection (line 65) | public ClickHouseConnection OpenConnection(Action<ClickHouseConnection...
method WithTemporaryTable (line 73) | protected Task WithTemporaryTable(string tableNameSuffix, string colum...
method WithTemporaryTable (line 78) | protected Task WithTemporaryTable(
method WithTemporaryTable (line 89) | protected async Task WithTemporaryTable(
method GetTempTableName (line 121) | protected virtual string GetTempTableName(string tableNameSuffix)
FILE: src/Octonica.ClickHouseClient.Tests/ClickHouseTypeInfoTests.cs
class ClickHouseTypeInfoTests (line 26) | public class ClickHouseTypeInfoTests
method NullableGenericArguments (line 28) | [Theory]
method LowCardinalityGenericArguments (line 43) | [Theory]
method TupleGenericArguments (line 57) | [Fact]
method ArrayGenericArguments (line 81) | [Theory]
method DecimalTypeArguments (line 110) | [Theory]
method DateTimeTypeArguments (line 130) | [Fact]
method DateTime64TypeArguments (line 148) | [Fact]
method Enum8TypeArguments (line 169) | [Theory]
method Enum16TypeArguments (line 192) | [Theory]
method FixedStringTypeArguments (line 215) | [Fact]
method NamedTupleArguments (line 227) | [Fact]
FILE: src/Octonica.ClickHouseClient.Tests/CommonUtilsTests.cs
class CommonUtilsTests (line 27) | public class CommonUtilsTests
method GetColumnIndex (line 29) | [Fact]
FILE: src/Octonica.ClickHouseClient.Tests/EncodingFixture.cs
class EncodingFixture (line 22) | internal class EncodingFixture
method EncodingFixture (line 24) | static EncodingFixture()
FILE: src/Octonica.ClickHouseClient.Tests/IndexedCollectionTests.cs
class IndexedCollectionTests (line 25) | public class IndexedCollectionTests
method Add (line 27) | [Fact]
method Insert (line 84) | [Fact]
method Remove (line 137) | [Theory]
FILE: src/Octonica.ClickHouseClient.Tests/ListExtensionsTests.cs
class ListExtensionsTests (line 26) | public class ListExtensionsTests
method SliceArray (line 28) | [Fact]
method SliceReadOnlyList (line 67) | [Fact]
method SliceList (line 89) | [Fact]
method MapArray (line 111) | [Fact]
method MapReadOnlyList (line 123) | [Fact]
method MapList (line 131) | [Fact]
method SliceMapArray (line 139) | [Fact]
method SliceMapReadOnlyList (line 252) | [Fact]
method SliceMapList (line 360) | [Fact]
method ArrayCopyTo (line 468) | [Fact]
method ListCopyTo (line 475) | [Fact]
method TestSlice (line 482) | private static void TestSlice<T>(IReadOnlyList<T> expected, IReadOnlyL...
method TestCopyTo (line 510) | private static void TestCopyTo<T>(IReadOnlyList<T> list)
FILE: src/Octonica.ClickHouseClient.Tests/ReadWriteBufferTests.cs
class ReadWriteBufferTests (line 26) | public class ReadWriteBufferTests
method WriteBlocks (line 28) | [Fact]
method WriteExactThreeBlocks (line 71) | [Fact]
method ReadWriteSequentialWithoutSegmentOverflow (line 96) | [Fact]
method ReadWriteSequentialWithSegmentOverflow (line 156) | [Fact]
method FlushDiscardWithoutSegmentOverflow (line 212) | [Fact]
method FlushDiscardWithSegmentOverflow (line 282) | [Fact]
FILE: src/Octonica.ClickHouseClient.Tests/TestBox.cs
type TestBox (line 20) | internal readonly struct TestBox<T>
method TestBox (line 24) | public TestBox(T value)
method Unbox (line 29) | public T Unbox() => _value;
FILE: src/Octonica.ClickHouseClient.Tests/TestEnum.cs
type TestEnum (line 20) | internal enum TestEnum
FILE: src/Octonica.ClickHouseClient.Tests/TestIndexedCollection.cs
class TestIndexedCollection (line 23) | internal sealed class TestIndexedCollection<TKey, TValue> : IndexedColle...
method TestIndexedCollection (line 26) | public TestIndexedCollection(IEqualityComparer<TKey>? comparer = null)
method GetKey (line 31) | protected override TKey GetKey(KeyValuePair<TKey, TValue> item)
FILE: src/Octonica.ClickHouseClient.Tests/TestListWrappers.cs
class ListWrapperBase (line 29) | internal abstract class ListWrapperBase<T>
method ListWrapperBase (line 37) | protected ListWrapperBase(List<T> list)
method GetEnumerator (line 42) | public IEnumerator<T> GetEnumerator()
method Add (line 47) | public void Add(T item)
method Clear (line 52) | public void Clear()
method Contains (line 57) | public bool Contains(T item)
method CopyTo (line 62) | public void CopyTo(T[] array, int arrayIndex)
method Remove (line 67) | public bool Remove(T item)
method IndexOf (line 72) | public int IndexOf(T item)
method Insert (line 77) | public void Insert(int index, T item)
method RemoveAt (line 82) | public void RemoveAt(int index)
class EnumerableListWrapper (line 94) | internal sealed class EnumerableListWrapper<T> : ListWrapperBase<T>, IEn...
method EnumerableListWrapper (line 96) | public EnumerableListWrapper(List<T> list)
method GetEnumerator (line 101) | IEnumerator IEnumerable.GetEnumerator()
class GenericEnumerableListWrapper (line 107) | internal sealed class GenericEnumerableListWrapper<T> : ListWrapperBase<...
method GenericEnumerableListWrapper (line 109) | public GenericEnumerableListWrapper(List<T> list)
method GetEnumerator (line 114) | IEnumerator IEnumerable.GetEnumerator()
class ListWrapper (line 120) | internal sealed class ListWrapper<T> : ListWrapperBase<T>, IList<T>
method ListWrapper (line 122) | public ListWrapper(List<T> list)
method GetEnumerator (line 127) | IEnumerator IEnumerable.GetEnumerator()
class AsyncEnumerableListWrapper (line 133) | internal sealed class AsyncEnumerableListWrapper<T> : IAsyncEnumerable<T>
method AsyncEnumerableListWrapper (line 137) | public AsyncEnumerableListWrapper(IReadOnlyList<T> list)
method GetAsyncEnumerator (line 142) | public IAsyncEnumerator<T> GetAsyncEnumerator(CancellationToken cancel...
class Enumerator (line 147) | private class Enumerator : IAsyncEnumerator<T>
method Enumerator (line 155) | public Enumerator(IReadOnlyList<T> list)
method DisposeAsync (line 160) | public ValueTask DisposeAsync()
method MoveNextAsync (line 165) | public ValueTask<bool> MoveNextAsync()
class Int32ToUInt32MappedListWrapper (line 175) | internal sealed class Int32ToUInt32MappedListWrapper : ListWrapperBase<i...
method Int32ToUInt32MappedListWrapper (line 179) | public Int32ToUInt32MappedListWrapper(List<int> list, Func<int, uint> ...
method GetEnumerator (line 185) | IEnumerator IEnumerable.GetEnumerator()
method GetEnumerator (line 190) | IEnumerator<uint> IEnumerable<uint>.GetEnumerator()
FILE: src/Octonica.ClickHouseClient.Tests/TypeTests.cs
class TypeTests (line 36) | public class TypeTests : ClickHouseTestsBase, IClassFixture<EncodingFixt...
method ReadFixedStringScalar (line 38) | [Fact]
method ReadFixedStringWithEncoding (line 56) | [Fact]
method ReadNullableFixedStringAsArray (line 92) | [Fact]
method ReadStringWithEncoding (line 179) | [Fact]
method ReadStringWithEncodingScalar (line 204) | [Fact]
method ReadStringParameterScalar (line 217) | [Theory]
method ReadStringArrayParameterScalar (line 244) | [Theory]
method ReadMultidimensionalStringArrayParameterScalar (line 268) | [Theory]
method ReadGuidScalar (line 312) | [Fact]
method ReadDecimal128Scalar (line 326) | [Fact]
method ReadDecimal64Scalar (line 356) | [Fact]
method ReadDecimal32Scalar (line 374) | [Fact]
method ReadDateTimeScalar (line 392) | [Fact]
method ReadDateTimeWithTimezoneScalar (line 405) | [Fact]
method ReadDateTime64Scalar (line 420) | [Theory]
method ReadDateTime64WithTimezoneScalar (line 441) | [Fact]
method ReadDateTime64ParameterScalar (line 456) | [Theory]
method ReadDateTimeParameterWithTimezoneScalar (line 517) | [Theory]
method ReadFloatScalar (line 565) | [Fact]
method ReadDoubleScalar (line 579) | [Fact]
method ReadNothingScalar (line 592) | [Fact]
method ReadEmptyArrayScalar (line 603) | [Fact]
method ReadByteArrayScalar (line 615) | [Fact]
method ReadNullableByteArrayScalar (line 627) | [Fact]
method ReadArrayOfArraysOfArraysScalar (line 640) | [Fact]
method ReadNullableByteArrayAsUInt64ArrayScalar (line 678) | [Fact]
method ReadNullableStringArrayScalar (line 690) | [Fact]
method ReadNullableNothingArrayScalar (line 702) | [Fact]
method ReadArrayParameterScalar (line 715) | [Theory]
method ReadArrayOfArraysParameterScalar (line 739) | [Theory]
method ReadMultidimensionalArrayParameterScalar (line 768) | [Theory]
method ReadEnumColumn (line 816) | [Fact]
method ReadEnumScalar (line 874) | [Fact]
method ReadClrEnumScalar (line 885) | [Fact]
method ReadInt32ArrayColumn (line 897) | [Fact]
method SkipInt32ArrayColumn (line 954) | [Fact]
method ReadTuplesWithDifferentLength (line 994) | [Fact]
method ReadValueTuplesWithDifferentLength (line 1071) | [Fact]
method ReadTupleColumn (line 1164) | [Fact]
method ReadValueTupleColumn (line 1219) | [Fact]
method ReadNamedTupleScalar (line 1274) | [Fact]
method SkipTupleColumn (line 1283) | [Fact]
method ReadIpV4Column (line 1299) | [Fact]
method ReadIpV6Column (line 1340) | [Fact]
method ReadLowCardinalityColumn (line 1381) | [Fact]
method ReadNullableLowCardinalityColumn (line 1428) | [Fact]
method ReadNullableStringLowCardinalityColumnAsArray (line 1486) | [Fact]
method ReadStringLowCardinalityColumnAsArray (line 1573) | [Fact]
method SkipLowCardinalityColumn (line 1653) | [Fact]
method ReadFixedStringParameterScalar (line 1705) | [Theory]
method ReadRandomFixedStringParameterScalar (line 1736) | [Theory]
method ReadGuidParameterScalar (line 1767) | [Theory]
method ReadDecimalParameterScalar (line 1784) | [Theory]
method ReadCurrencyParameterScalar (line 1818) | [Theory]
method ReadVarNumericParameter (line 1858) | [Theory]
method ClickHouseDecimalTypeNames (line 1994) | [Theory]
method ReadDateTimeParameterScalar (line 2042) | [Theory]
method ReadDateTimeOffsetParameterScalar (line 2074) | [Theory]
method ReadFloatParameterScalar (line 2115) | [Theory]
method ReadDoubleParameterScalar (line 2139) | [Theory]
method ReadNothingParameterScalar (line 2163) | [Theory]
method ReadIpV4ParameterScalar (line 2177) | [Theory]
method ReadIpV6ParameterScalar (line 2197) | [Theory]
method ReadIntegerParameterScalar (line 2221) | [Theory]
method ReadValueWithOverridenType (line 2264) | [Fact]
method ReadGuidColumn (line 2326) | [Fact]
method ReadMapScalar (line 2366) | [Fact]
method ReadMapColumn (line 2377) | [Fact]
method ReadInt128Column (line 2458) | [Fact]
method ReadInt128ParameterScalar (line 2503) | [Theory]
method ReadUInt128Column (line 2543) | [Fact]
method ReadUInt128ParameterScalar (line 2587) | [Theory]
method ReadInt256Column (line 2617) | [Fact]
method ReadInt256ParameterScalar (line 2661) | [Theory]
method ReadUInt256Column (line 2704) | [Fact]
method ReadUInt256ParameterScalar (line 2749) | [Theory]
method ReadArrayLowCardinality (line 2779) | [Fact]
method ReadDateScalar (line 2843) | [Theory]
method ReadDateParameterScalar (line 2881) | [Theory]
method ReadDateParameterScalarNet6 (line 2923) | [Theory]
method ReadDate32Scalar (line 2968) | [Theory]
method ReadDate32ParameterScalar (line 3009) | [Theory]
method ReadDate32ParameterScalarNet6 (line 3057) | [Theory]
method ReadMultidimensionalArrayLowCardinality (line 3105) | [Fact]
method ReadBoolScalar (line 3177) | [Theory]
method ReadBoolParameter (line 3194) | [Theory]
method ReadVariant (line 3246) | [Fact]
method CreateInsertSelectAllKnownNullable (line 3292) | [Fact]
FILE: src/Octonica.ClickHouseClient/ClickHouseBinaryProtocolReader.cs
method ClickHouseBinaryProtocolReader (line 40) | public ClickHouseBinaryProtocolReader(Stream stream, int bufferSize)
method BeginDecompress (line 47) | internal void BeginDecompress(CompressionAlgorithm algorithm)
method EndDecompress (line 78) | internal void EndDecompress()
FILE: src/Octonica.ClickHouseClient/ClickHouseBinaryProtocolWriter.cs
class ClickHouseBinaryProtocolWriter (line 30) | internal class ClickHouseBinaryProtocolWriter : IDisposable
method ClickHouseBinaryProtocolWriter (line 41) | public ClickHouseBinaryProtocolWriter(Stream stream, int bufferSize)
method Flush (line 48) | public async ValueTask Flush(bool async, CancellationToken cancellatio...
FILE: src/Octonica.ClickHouseClient/ClickHouseColumnSettings.cs
class ClickHouseColumnSettings (line 28) | public class ClickHouseColumnSettings
method ClickHouseColumnSettings (line 53) | public ClickHouseColumnSettings(Encoding stringEncoding)
method ClickHouseColumnSettings (line 62) | public ClickHouseColumnSettings(IClickHouseEnumConverter enumConverter)
method ClickHouseColumnSettings (line 75) | public ClickHouseColumnSettings(Type columnType)
method ClickHouseColumnSettings (line 90) | public ClickHouseColumnSettings(Encoding? stringEncoding = null, IClic...
method GetColumnTypeDispatcher (line 97) | internal ITypeDispatcher? GetColumnTypeDispatcher()
FILE: src/Octonica.ClickHouseClient/ClickHouseColumnWriter.cs
class ClickHouseColumnWriter (line 38) | public sealed class ClickHouseColumnWriter : IDisposable, IAsyncDisposable
method ClickHouseColumnWriter (line 81) | internal ClickHouseColumnWriter(ClickHouseTcpClient.Session session, C...
method ReadTableMetadata (line 95) | internal static async ValueTask<ClickHouseTable> ReadTableMetadata(Cli...
method ConfigureColumn (line 129) | public void ConfigureColumn(string name, ClickHouseColumnSettings column...
method ConfigureColumn (line 139) | public void ConfigureColumn(int ordinal, ClickHouseColumnSettings column...
method ConfigureColumnWriter (line 148) | public void ConfigureColumnWriter(ClickHouseColumnSettings columnSettings)
method GetFieldTypeInfo (line 158) | public IClickHouseTypeInfo GetFieldTypeInfo(int ordinal)
method GetName (line 164) | public string GetName(int ordinal)
method GetDataTypeName (line 170) | public string GetDataTypeName(int ordinal)
method GetFieldType (line 176) | public Type GetFieldType(int ordinal)
method GetOrdinal (line 186) | public int GetOrdinal(string name)
method WriteRow (line 199) | public void WriteRow(params object?[] values)
method WriteRow (line 210) | public void WriteRow(IReadOnlyCollection<object?> values)
method WriteRow (line 224) | public void WriteRow(IReadOnlyCollection<object?> values, bool commit)
method WriteRowAsync (line 235) | public async Task WriteRowAsync(IReadOnlyCollection<object?> values)
method WriteRowAsync (line 250) | public async Task WriteRowAsync(IReadOnlyCollection<object?> values, boo...
method WriteRowAsync (line 262) | public async Task WriteRowAsync(IReadOnlyCollection<object?> values, Can...
method WriteRowAsync (line 277) | public async Task WriteRowAsync(IReadOnlyCollection<object?> values, boo...
method WriteRow (line 282) | private async ValueTask WriteRow(IReadOnlyCollection<object?> values, bo...
method WriteTable (line 383) | public void WriteTable(IReadOnlyDictionary<string, object?> columns, int...
method WriteTable (line 400) | public void WriteTable(IReadOnlyDictionary<string, object?> columns, int...
method WriteTable (line 416) | public void WriteTable(IReadOnlyList<object?> columns, int rowCount)
method WriteTable (line 433) | public void WriteTable(IReadOnlyList<object?> columns, int rowCount, Cli...
method WriteTableAsync (line 452) | public async Task WriteTableAsync(IReadOnlyDictionary<string, object?> c...
method WriteTableAsync (line 472) | public async Task WriteTableAsync(IReadOnlyDictionary<string, object?> c...
method WriteTableAsync (line 491) | public async Task WriteTableAsync(IReadOnlyList<object?> columns, int ro...
method WriteTableAsync (line 511) | public async Task WriteTableAsync(IReadOnlyList<object?> columns, int ro...
method WriteTable (line 516) | private async ValueTask WriteTable(IReadOnlyDictionary<string, object?> ...
method WriteTable (line 533) | private async ValueTask WriteTable(IReadOnlyList<object?> columns, int r...
method SendTable (line 569) | private async ValueTask SendTable(ClickHouseTableWriter table, bool comm...
method RepeatQuery (line 595) | private async ValueTask RepeatQuery(bool async, CancellationToken cancel...
method Commit (line 666) | public void Commit()
method CommitAsync (line 678) | public async Task CommitAsync(CancellationToken cancellationToken)
method EndWrite (line 686) | public void EndWrite()
method Rollback (line 695) | public void Rollback()
method RollbackAsync (line 707) | public async Task RollbackAsync(CancellationToken cancellationToken)
method EndWriteAsync (line 717) | public async Task EndWriteAsync(CancellationToken cancellationToken)
method EndWrite (line 722) | private async ValueTask EndWrite(TerminationMode mode, bool closeSession...
class AsyncObjectColumnWriterDispatcher (line 1157) | private class AsyncObjectColumnWriterDispatcher : ITypeDispatcher<Task<I...
method AsyncObjectColumnWriterDispatcher (line 1166) | public AsyncObjectColumnWriterDispatcher(
method Dispatch (line 1182) | public async Task<IClickHouseColumnWriterFactory> Dispatch<T>()
class ColumnWriterDispatcher (line 1217) | private class ColumnWriterDispatcher : ITypeDispatcher<IClickHouseColumn...
method ColumnWriterDispatcher (line 1226) | public ColumnWriterDispatcher(
method Dispatch (line 1242) | public IClickHouseColumnWriterFactory? Dispatch<T>()
class ColumnWriterObjectCollectionDispatcher (line 1302) | private class ColumnWriterObjectCollectionDispatcher : ITypeDispatcher<I...
method ColumnWriterObjectCollectionDispatcher (line 1312) | public ColumnWriterObjectCollectionDispatcher(
method Dispatch (line 1330) | public IClickHouseColumnWriterFactory? Dispatch<T>()
method CastTo (line 1415) | [MethodImpl(MethodImplOptions.AggressiveInlining)]
class SingleRowColumnWriterDispatcher (line 1426) | private class SingleRowColumnWriterDispatcher : ITypeDispatcher<IClickHo...
method SingleRowColumnWriterDispatcher (line 1432) | public SingleRowColumnWriterDispatcher(object? value, ColumnInfo colum...
method Dispatch (line 1439) | public IClickHouseColumnWriter Dispatch<T>()
type TerminationMode (line 1446) | private enum TerminationMode
FILE: src/Octonica.ClickHouseClient/ClickHouseCommand.cs
method ClickHouseCommand (line 171) | public ClickHouseCommand()
method ClickHouseCommand (line 175) | internal ClickHouseCommand(ClickHouseConnection connection)
method Cancel (line 184) | public override void Cancel()
method ExecuteNonQuery (line 193) | public override int ExecuteNonQuery()
method ExecuteNonQueryAsync (line 211) | public override async Task<int> ExecuteNonQueryAsync(CancellationToken c...
FILE: src/Octonica.ClickHouseClient/ClickHouseConnection.cs
method ClickHouseConnection (line 166) | public ClickHouseConnection()
method ClickHouseConnection (line 175) | public ClickHouseConnection(string connectionString)
method ClickHouseConnection (line 185) | public ClickHouseConnection(string connectionString, IClickHouseTypeInfo...
method ClickHouseConnection (line 194) | public ClickHouseConnection(ClickHouseConnectionStringBuilder stringBuil...
method ClickHouseConnection (line 204) | public ClickHouseConnection(ClickHouseConnectionStringBuilder stringBuil...
method ClickHouseConnection (line 219) | public ClickHouseConnection(ClickHouseConnectionSettings connectionSetti...
method ClickHouseConnection (line 229) | public ClickHouseConnection(ClickHouseConnectionSettings connectionSetti...
method ChangeDatabase (line 242) | public override void ChangeDatabase(string databaseName)
method ChangeDatabaseAsync (line 248) | public override Task ChangeDatabaseAsync(string databaseName, Cancellati...
method Close (line 256) | public override void Close()
method CloseAsync (line 262) | public override async Task CloseAsync()
method EnlistTransaction (line 271) | public override void EnlistTransaction(Transaction? transaction)
method GetSchema (line 280) | public override DataTable GetSchema()
method GetSchema (line 286) | public override DataTable GetSchema(string collectionName)
method GetSchema (line 292) | public override DataTable GetSchema(string collectionName, string?[] res...
method Open (line 300) | public override void Open()
method OpenAsync (line 310) | public override async Task OpenAsync(CancellationToken cancellationToken)
method BeginDbTransaction (line 319) | protected override DbTransaction BeginDbTransaction(System.Data.Isolatio...
method BeginDbTransactionAsync (line 328) | protected override ValueTask<DbTransaction> BeginDbTransactionAsync(Syst...
method CreateCommand (line 337) | public new ClickHouseCommand CreateCommand()
method CreateCommand (line 347) | public ClickHouseCommand CreateCommand(string commandText)
method CreateDbCommand (line 353) | protected override DbCommand CreateDbCommand()
method CreateColumnWriter (line 367) | public ClickHouseColumnWriter CreateColumnWriter(string insertFormatComm...
method CreateColumnWriterAsync (line 382) | public async Task<ClickHouseColumnWriter> CreateColumnWriterAsync(string...
method CreateColumnWriter (line 387) | private async ValueTask<ClickHouseColumnWriter> CreateColumnWriter(strin...
method GetServerTimeZone (line 442) | public TimeZoneInfo GetServerTimeZone()
method Dispose (line 455) | protected override void Dispose(bool disposing)
FILE: src/Octonica.ClickHouseClient/ClickHouseConnectionSettings.cs
class ClickHouseConnectionSettings (line 25) | public sealed class ClickHouseConnectionSettings
method ClickHouseConnectionSettings (line 113) | internal ClickHouseConnectionSettings(ClickHouseConnectionStringBuilde...
method ParseHashString (line 139) | private static byte[]? ParseHashString(string? hashString)
FILE: src/Octonica.ClickHouseClient/ClickHouseConnectionState.cs
class ClickHouseConnectionState (line 22) | internal sealed class ClickHouseConnectionState
method ClickHouseConnectionState (line 32) | public ClickHouseConnectionState()
method ClickHouseConnectionState (line 37) | public ClickHouseConnectionState(ConnectionState state, ClickHouseTcpC...
FILE: src/Octonica.ClickHouseClient/ClickHouseConnectionStringBuilder.cs
class ClickHouseConnectionStringBuilder (line 29) | public class ClickHouseConnectionStringBuilder : DbConnectionStringBuilder
method ClickHouseConnectionStringBuilder (line 269) | static ClickHouseConnectionStringBuilder()
method ClickHouseConnectionStringBuilder (line 299) | public ClickHouseConnectionStringBuilder()
method ClickHouseConnectionStringBuilder (line 307) | public ClickHouseConnectionStringBuilder(string connectionString)
method ClickHouseConnectionStringBuilder (line 316) | public ClickHouseConnectionStringBuilder(ClickHouseConnectionSettings ...
method BuildSettings (line 361) | public ClickHouseConnectionSettings BuildSettings()
method GetString (line 366) | private string? GetString(string key)
method GetStringOrDefault (line 371) | private string GetStringOrDefault(string key, string defaultValue)
method GetInt32OrDefault (line 379) | private int GetInt32OrDefault(string key, int defaultValue)
method GetBoolOrDefault (line 395) | private bool GetBoolOrDefault(string key, bool defaultValue)
method GetEnumOrDefault (line 422) | private TEnum GetEnumOrDefault<TEnum>(string key, TEnum defaultValue)
method HashToString (line 444) | private static string? HashToString(ReadOnlyMemory<byte> hashBytes)
method HashToString (line 452) | static void HashToString(Span<char> span, ReadOnlyMemory<byte> hashBytes)
FILE: src/Octonica.ClickHouseClient/ClickHouseDataReader.cs
method ClickHouseDataReader (line 110) | internal ClickHouseDataReader(ClickHouseTable table, ClickHouseTcpClient...
method ClickHouseDataReader (line 125) | internal ClickHouseDataReader(ClickHouseTcpClient.Session session)
method ConfigureColumn (line 144) | public void ConfigureColumn(string name, ClickHouseColumnSettings column...
method ConfigureColumn (line 159) | public void ConfigureColumn(int ordinal, ClickHouseColumnSettings column...
method ConfigureColumnReader (line 191) | public void ConfigureColumnReader<T, TResult>(string name, Func<T, TResu...
method ConfigureColumnReader (line 208) | public void ConfigureColumnReader<T, TResult>(int ordinal, Func<T, TResu...
method ConfigureColumnReader (line 243) | public void ConfigureColumnReader(int ordinal, IConverterDispatcher? rea...
method ConfigureDataReader (line 279) | public void ConfigureDataReader(ClickHouseColumnSettings columnSettings)
method ConfigureDataReader (line 310) | public void ConfigureDataReader(IConverterDispatcher readAsDispatcher)
method GetFieldTypeInfo (line 355) | public IClickHouseTypeInfo GetFieldTypeInfo(int ordinal)
method GetName (line 366) | public sealed override string GetName(int ordinal)
method GetDataTypeName (line 377) | public sealed override string GetDataTypeName(int ordinal)
method GetFieldType (line 388) | public override Type GetFieldType(int ordinal)
method GetOrdinal (line 406) | public sealed override int GetOrdinal(string name)
method GetBytes (line 423) | public sealed override long GetBytes(int ordinal, long dataOffset, byte[...
method GetChars (line 469) | public sealed override long GetChars(int ordinal, long dataOffset, char[...
method GetBigInteger (line 511) | public BigInteger GetBigInteger(int ordinal)
method GetBoolean (line 521) | public sealed override bool GetBoolean(int ordinal)
method GetByte (line 531) | public sealed override byte GetByte(int ordinal)
method GetSByte (line 541) | public sbyte GetSByte(int ordinal)
method GetChar (line 551) | public sealed override char GetChar(int ordinal)
method GetDate (line 562) | public DateOnly GetDate(int ordinal)
method GetDateTime (line 573) | public sealed override DateTime GetDateTime(int ordinal)
method GetDecimal (line 583) | public sealed override decimal GetDecimal(int ordinal)
method GetDouble (line 593) | public sealed override double GetDouble(int ordinal)
method GetFloat (line 603) | public sealed override float GetFloat(int ordinal)
method GetGuid (line 613) | public sealed override Guid GetGuid(int ordinal)
method GetInt16 (line 623) | public sealed override short GetInt16(int ordinal)
method GetUInt16 (line 633) | public ushort GetUInt16(int ordinal)
method GetInt32 (line 643) | public sealed override int GetInt32(int ordinal)
method GetUInt32 (line 653) | public uint GetUInt32(int ordinal)
method GetInt64 (line 663) | public sealed override long GetInt64(int ordinal)
method GetUInt64 (line 673) | public ulong GetUInt64(int ordinal)
method GetIPAddress (line 683) | public IPAddress GetIPAddress(int ordinal)
method GetString (line 693) | public sealed override string GetString(int ordinal)
method GetString (line 704) | [return: NotNullIfNotNull("nullValue")]
method GetDateTimeOffset (line 715) | public DateTimeOffset GetDateTimeOffset(int ordinal)
method GetFieldValue (line 727) | [return: NotNullIfNotNull("nullValue")]
method GetFieldValue (line 754) | [return: NotNullIfNotNull("nullValue")]
method GetFieldValue (line 797) | public sealed override T GetFieldValue<T>(int ordinal)
method GetValue (line 826) | public sealed override object GetValue(int ordinal)
method GetValues (line 838) | public sealed override int GetValues(object[] values)
method IsDBNull (line 856) | public sealed override bool IsDBNull(int ordinal)
method Read (line 887) | public sealed override bool Read()
method ReadAsync (line 899) | public new ValueTask<bool> ReadAsync()
method ReadAsync (line 912) | public new ValueTask<bool> ReadAsync(CancellationToken cancellationToken)
method ReadAsyncInternal (line 918) | protected sealed override async Task<bool> ReadAsyncInternal(Cancellatio...
method Read (line 923) | private async ValueTask<bool> Read(bool async, CancellationToken cancell...
method Read (line 956) | private async ValueTask<bool> Read(bool nextResult, bool async, Cancella...
method NextResultAsync (line 1153) | public override async Task<bool> NextResultAsync(CancellationToken cance...
method NextResult (line 1162) | public override bool NextResult()
method NextResult (line 1167) | private async ValueTask<bool> NextResult(bool async, CancellationToken c...
method Cancel (line 1186) | private async ValueTask Cancel(bool disposing, bool async)
method Close (line 1209) | public override void Close()
method CloseAsync (line 1218) | public override async Task CloseAsync()
FILE: src/Octonica.ClickHouseClient/ClickHouseDataReaderBase.cs
class ClickHouseDataReaderBase (line 27) | public abstract class ClickHouseDataReaderBase : DbDataReader
method ClickHouseDataReaderBase (line 29) | private protected ClickHouseDataReaderBase()
method ReadAsync (line 34) | public sealed override Task<bool> ReadAsync(CancellationToken cancella...
method ReadAsyncInternal (line 47) | protected abstract Task<bool> ReadAsyncInternal(CancellationToken canc...
FILE: src/Octonica.ClickHouseClient/ClickHouseDataReaderRowLimit.cs
type ClickHouseDataReaderRowLimit (line 20) | internal enum ClickHouseDataReaderRowLimit
FILE: src/Octonica.ClickHouseClient/ClickHouseDataReaderState.cs
type ClickHouseDataReaderState (line 23) | public enum ClickHouseDataReaderState
FILE: src/Octonica.ClickHouseClient/ClickHouseDbProviderFactory.cs
class ClickHouseDbProviderFactory (line 25) | public class ClickHouseDbProviderFactory : DbProviderFactory
method CreateConnectionStringBuilder (line 31) | public override DbConnectionStringBuilder CreateConnectionStringBuilder()
method CreateConnection (line 40) | public override DbConnection CreateConnection()
method CreateCommand (line 49) | public override DbCommand CreateCommand()
method CreateParameter (line 58) | public override DbParameter CreateParameter()
FILE: src/Octonica.ClickHouseClient/ClickHouseDbType.cs
type ClickHouseDbType (line 25) | public enum ClickHouseDbType
FILE: src/Octonica.ClickHouseClient/ClickHouseFlushMode.cs
type ClickHouseTransactionMode (line 25) | public enum ClickHouseTransactionMode
FILE: src/Octonica.ClickHouseClient/ClickHouseParameter.cs
class ClickHouseParameter (line 37) | public sealed class ClickHouseParameter : DbParameter, ICloneable
method ClickHouseParameter (line 295) | public ClickHouseParameter()
method ClickHouseParameter (line 304) | public ClickHouseParameter(string parameterName)
method ResetDbType (line 314) | public override void ResetDbType()
method Clone (line 328) | object ICloneable.Clone()
method Clone (line 337) | public ClickHouseParameter Clone()
method CopyTo (line 348) | public void CopyTo(ClickHouseParameter parameter)
method CreateParameterWriter (line 370) | internal ClickHouseParameterWriter CreateParameterWriter(IClickHouseTy...
method CreateParameterColumnWriter (line 380) | internal IClickHouseColumnWriter CreateParameterColumnWriter(IClickHou...
method CreateParameterWriter (line 392) | private T CreateParameterWriter<T>(IClickHouseTypeInfoProvider typeInf...
method GetTypeInfo (line 444) | internal IClickHouseColumnTypeInfo GetTypeInfo(IClickHouseTypeInfoProv...
method GetTypeFromValue (line 457) | private IntermediateClickHouseTypeInfo GetTypeFromValue()
method GetValueDependentType (line 480) | private IntermediateClickHouseTypeInfo? GetValueDependentType()
method IsValidParameterName (line 503) | public static bool IsValidParameterName(string? parameterName)
method GetId (line 508) | private static string GetId(string? parameterName)
method ValidateParameterName (line 516) | private static bool ValidateParameterName(string? parameterName, [Mayb...
method GetParameterMode (line 528) | internal ClickHouseParameterMode GetParameterMode(ClickHouseParameterM...
method TrimParameterName (line 537) | internal static string TrimParameterName(string parameterName)
class ParameterColumnWriterBuilder (line 552) | private class ParameterColumnWriterBuilder : ITypeDispatcher<IClickHou...
method ParameterColumnWriterBuilder (line 559) | public ParameterColumnWriterBuilder(string parameterId, object? valu...
method Dispatch (line 567) | public IClickHouseColumnWriter Dispatch<T>()
class ParameterColumnTypeDescriptorAdapter (line 574) | private class ParameterColumnTypeDescriptorAdapter : IClickHouseColumn...
method ParameterColumnTypeDescriptorAdapter (line 594) | public ParameterColumnTypeDescriptorAdapter(ClickHouseParameter para...
FILE: src/Octonica.ClickHouseClient/ClickHouseParameterCollection.cs
class ClickHouseParameterCollection (line 32) | public sealed class ClickHouseParameterCollection : DbParameterCollectio...
method Add (line 45) | public override int Add(object value)
method AddWithValue (line 60) | public ClickHouseParameter AddWithValue(string parameterName, object? ...
method AddWithValue (line 74) | public ClickHouseParameter AddWithValue(string parameterName, object? ...
method AddWithValue (line 86) | public ClickHouseParameter AddWithValue(string parameterName, object? ...
method Add (line 93) | void ICollection<ClickHouseParameter>.Add(ClickHouseParameter item)
method Add (line 103) | public int Add(ClickHouseParameter item)
method Clear (line 129) | public override void Clear()
method Contains (line 139) | public bool Contains(ClickHouseParameter item)
method CopyTo (line 145) | public void CopyTo(ClickHouseParameter[] array, int arrayIndex)
method Contains (line 153) | public override bool Contains(object value)
method IndexOf (line 162) | public override int IndexOf(object value)
method Insert (line 171) | public override void Insert(int index, object value)
method Remove (line 181) | public bool Remove(ClickHouseParameter item)
method Remove (line 206) | public bool Remove(string parameterName)
method Remove (line 217) | public bool Remove(string parameterName, [MaybeNullWhen(false)] out Cl...
method Remove (line 234) | public override void Remove(object value)
method IndexOf (line 243) | public int IndexOf(ClickHouseParameter item)
method Insert (line 259) | public void Insert(int index, ClickHouseParameter item)
method RemoveAt (line 282) | public override void RemoveAt(int index)
method RemoveAt (line 292) | public override void RemoveAt(string parameterName)
method SetParameter (line 298) | protected override void SetParameter(int index, DbParameter value)
method SetParameter (line 350) | protected override void SetParameter(string parameterName, DbParameter...
method IndexOf (line 410) | public override int IndexOf(string parameterName)
method Contains (line 422) | public override bool Contains(string value)
method CopyTo (line 432) | public override void CopyTo(Array array, int index)
method GetEnumerator (line 442) | IEnumerator<ClickHouseParameter> IEnumerable<ClickHouseParameter>.GetE...
method GetEnumerator (line 448) | public override IEnumerator GetEnumerator()
method GetParameter (line 454) | protected override DbParameter GetParameter(int index)
method GetParameter (line 460) | protected override DbParameter GetParameter(string parameterName)
method AddRange (line 469) | public override void AddRange(Array values)
method AddRange (line 483) | public void AddRange(IEnumerable<ClickHouseParameter> parameters)
method TryGetValue (line 501) | public bool TryGetValue(string parameterName, [NotNullWhen(true)] out ...
method OnParameterIdChanged (line 510) | internal void OnParameterIdChanged(string originalId, ClickHouseParame...
FILE: src/Octonica.ClickHouseClient/ClickHouseParameterMode.cs
type ClickHouseParameterMode (line 23) | public enum ClickHouseParameterMode
FILE: src/Octonica.ClickHouseClient/ClickHousePasswordComplexityRule.cs
class ClickHousePasswordComplexityRule (line 23) | public sealed class ClickHousePasswordComplexityRule
method ClickHousePasswordComplexityRule (line 40) | public ClickHousePasswordComplexityRule(string originalPattern, string...
FILE: src/Octonica.ClickHouseClient/ClickHouseQueryExecutionProgress.cs
type ClickHouseQueryExecutionProgress (line 23) | public readonly struct ClickHouseQueryExecutionProgress
method ClickHouseQueryExecutionProgress (line 63) | public ClickHouseQueryExecutionProgress(ulong rows, ulong bytes, ulong...
FILE: src/Octonica.ClickHouseClient/ClickHouseReaderColumnSettings.cs
type ClickHouseReaderColumnSettings (line 24) | internal readonly struct ClickHouseReaderColumnSettings
method ClickHouseReaderColumnSettings (line 30) | public ClickHouseReaderColumnSettings(ClickHouseColumnSettings? column...
method WithColumnSettings (line 36) | public ClickHouseReaderColumnSettings WithColumnSettings(string column...
method WithUserDefinedReader (line 53) | public ClickHouseReaderColumnSettings WithUserDefinedReader(string col...
FILE: src/Octonica.ClickHouseClient/ClickHouseServerInfo.cs
class ClickHouseServerInfo (line 26) | public sealed class ClickHouseServerInfo
method ClickHouseServerInfo (line 73) | public ClickHouseServerInfo(string name, ClickHouseVersion version, in...
method WithTimezone (line 89) | public ClickHouseServerInfo WithTimezone(string timezone)
FILE: src/Octonica.ClickHouseClient/ClickHouseTable.cs
type ClickHouseTable (line 24) | internal struct ClickHouseTable
method ClickHouseTable (line 30) | public ClickHouseTable(BlockHeader header, ReadOnlyCollection<IClickHo...
FILE: src/Octonica.ClickHouseClient/ClickHouseTableColumn.cs
class ClickHouseTableColumn (line 27) | public class ClickHouseTableColumn : IClickHouseColumnDescriptor
method ClickHouseTableColumn (line 100) | public ClickHouseTableColumn(string columnName, object value, Type val...
FILE: src/Octonica.ClickHouseClient/ClickHouseTableColumnCollection.cs
class ClickHouseTableColumnCollection (line 31) | public sealed class ClickHouseTableColumnCollection : IndexedCollectionB...
method ClickHouseTableColumnCollection (line 36) | public ClickHouseTableColumnCollection()
method ClickHouseTableColumnCollection (line 45) | public ClickHouseTableColumnCollection(int capacity)
method GetKey (line 51) | protected sealed override string GetKey(ClickHouseTableColumn item)
method GetUniqueColumnName (line 56) | private string GetUniqueColumnName(string baseName)
method AddColumn (line 74) | public ClickHouseTableColumn AddColumn<T>(IReadOnlyList<T> column)
method AddColumn (line 86) | public ClickHouseTableColumn AddColumn<T>(string columnName, IReadOnly...
method AddColumn (line 107) | public ClickHouseTableColumn AddColumn(object column)
method AddColumn (line 125) | public ClickHouseTableColumn AddColumn(string columnName, object column)
method AddColumn (line 223) | public ClickHouseTableColumn AddColumn(object column, Type columnType)
method AddColumn (line 242) | public ClickHouseTableColumn AddColumn(string columnName, object colum...
method CreateInterfaceAmbiguousException (line 249) | private static ClickHouseException CreateInterfaceAmbiguousException(T...
FILE: src/Octonica.ClickHouseClient/ClickHouseTableProvider.cs
class ClickHouseTableProvider (line 26) | public sealed class ClickHouseTableProvider : IClickHouseTableProvider
method ClickHouseTableProvider (line 47) | public ClickHouseTableProvider(string tableName, int rowCount)
method AddColumn (line 59) | public ClickHouseTableColumn AddColumn(object column)
method AddColumn (line 65) | public ClickHouseTableColumn AddColumn(object column, Type columnType)
method AddColumn (line 71) | public ClickHouseTableColumn AddColumn(string columnName, object column)
method AddColumn (line 77) | public ClickHouseTableColumn AddColumn(string columnName, object colum...
method AddColumn (line 83) | public ClickHouseTableColumn AddColumn<T>(IReadOnlyList<T> column)
method AddColumn (line 89) | public ClickHouseTableColumn AddColumn<T>(string columnName, IReadOnly...
method GetColumn (line 94) | object IClickHouseTableProvider.GetColumn(int index)
method GetColumnDescriptor (line 99) | IClickHouseColumnDescriptor IClickHouseTableProvider.GetColumnDescript...
FILE: src/Octonica.ClickHouseClient/ClickHouseTableProviderCollection.cs
class ClickHouseTableProviderCollection (line 26) | public sealed class ClickHouseTableProviderCollection : IndexedCollectio...
method ClickHouseTableProviderCollection (line 31) | public ClickHouseTableProviderCollection()
method ClickHouseTableProviderCollection (line 40) | public ClickHouseTableProviderCollection(int capacity)
method GetKey (line 46) | protected sealed override string GetKey(IClickHouseTableProvider item)
FILE: src/Octonica.ClickHouseClient/ClickHouseTableWriter.cs
class ClickHouseTableWriter (line 25) | internal sealed class ClickHouseTableWriter : IClickHouseTableWriter
method ClickHouseTableWriter (line 33) | public ClickHouseTableWriter(string tableName, int rowCount, IEnumerab...
method ClickHouseTableWriter (line 43) | public ClickHouseTableWriter(string tableName, int rowCount, IReadOnly...
FILE: src/Octonica.ClickHouseClient/ClickHouseTcpClient.cs
method ClickHouseTcpClient (line 51) | public ClickHouseTcpClient(
FILE: src/Octonica.ClickHouseClient/ClickHouseTcpClientState.cs
type ClickHouseTcpClientState (line 20) | internal enum ClickHouseTcpClientState
FILE: src/Octonica.ClickHouseClient/ClickHouseTlsMode.cs
type ClickHouseTlsMode (line 23) | public enum ClickHouseTlsMode
FILE: src/Octonica.ClickHouseClient/ClickHouseVersion.cs
type ClickHouseVersion (line 26) | public readonly struct ClickHouseVersion : IEquatable<ClickHouseVersion>
method ClickHouseVersion (line 49) | public ClickHouseVersion(int major, int minor, int build)
method ToString (line 60) | public override string ToString()
method Equals (line 66) | public bool Equals(ClickHouseVersion other)
method Equals (line 72) | public override bool Equals(object? obj)
method GetHashCode (line 78) | public override int GetHashCode()
method Parse (line 96) | public static ClickHouseVersion Parse(string value)
FILE: src/Octonica.ClickHouseClient/Exceptions/ClickHouseErrorCodes.cs
class ClickHouseErrorCodes (line 25) | public static class ClickHouseErrorCodes
FILE: src/Octonica.ClickHouseClient/Exceptions/ClickHouseException.cs
class ClickHouseException (line 25) | public class ClickHouseException : Exception
method ClickHouseException (line 36) | public ClickHouseException(int errorCode)
method ClickHouseException (line 46) | public ClickHouseException(int errorCode, string? message)
method ClickHouseException (line 58) | public ClickHouseException(int errorCode, string? message, Exception? ...
FILE: src/Octonica.ClickHouseClient/Exceptions/ClickHouseHandledException.cs
class ClickHouseHandledException (line 25) | public sealed class ClickHouseHandledException : ClickHouseException
method ClickHouseHandledException (line 27) | private ClickHouseHandledException(int errorCode, string message, Exce...
method Wrap (line 32) | internal static ClickHouseHandledException Wrap(Exception exception)
FILE: src/Octonica.ClickHouseClient/Exceptions/ClickHouseServerException.cs
class ClickHouseServerException (line 26) | public sealed class ClickHouseServerException : ClickHouseException
method ClickHouseServerException (line 56) | public ClickHouseServerException(int serverErrorCode, string serverErr...
method ClickHouseServerException (line 73) | public ClickHouseServerException(int serverErrorCode, string serverErr...
method ClickHouseServerException (line 81) | private ClickHouseServerException(int serverErrorCode, string serverEr...
method ClickHouseServerException (line 90) | private ClickHouseServerException(int serverErrorCode, string serverEr...
method CopyWithQuery (line 104) | public ClickHouseServerException CopyWithQuery(string query)
FILE: src/Octonica.ClickHouseClient/IClickHouseArrayTableColumn.cs
type IClickHouseArrayTableColumn (line 26) | public interface IClickHouseArrayTableColumn<TElement> : IClickHouseTabl...
method CopyTo (line 35) | int CopyTo(int index, Span<TElement> buffer, int dataOffset);
FILE: src/Octonica.ClickHouseClient/IClickHouseColumnDescriptor.cs
type IClickHouseColumnDescriptor (line 25) | public interface IClickHouseColumnDescriptor : IClickHouseColumnTypeDesc...
FILE: src/Octonica.ClickHouseClient/IClickHouseSessionExternalResources.cs
type IClickHouseSessionExternalResources (line 23) | internal interface IClickHouseSessionExternalResources
method Release (line 25) | ValueTask Release(bool async);
method ReleaseOnFailure (line 27) | ValueTask<Exception?> ReleaseOnFailure(Exception? exception, bool async);
FILE: src/Octonica.ClickHouseClient/IClickHouseTableColumn.cs
type IClickHouseTableColumn (line 25) | public interface IClickHouseTableColumn
method IsNull (line 37) | bool IsNull(int index);
method GetValue (line 44) | object GetValue(int index);
method TryReinterpret (line 52) | IClickHouseTableColumn<T>? TryReinterpret<T>();
method TryReinterpretAsArray (line 60) | IClickHouseArrayTableColumn<T>? TryReinterpretAsArray<T>() => null;
method TryDipatch (line 69) | bool TryDipatch<T>(IClickHouseTableColumnDispatcher<T> dispatcher, [Ma...
method GetValue (line 88) | new T GetValue(int index);
type IClickHouseTableColumn (line 75) | public interface IClickHouseTableColumn<out T> : IClickHouseTableColumn
method IsNull (line 37) | bool IsNull(int index);
method GetValue (line 44) | object GetValue(int index);
method TryReinterpret (line 52) | IClickHouseTableColumn<T>? TryReinterpret<T>();
method TryReinterpretAsArray (line 60) | IClickHouseArrayTableColumn<T>? TryReinterpretAsArray<T>() => null;
method TryDipatch (line 69) | bool TryDipatch<T>(IClickHouseTableColumnDispatcher<T> dispatcher, [Ma...
method GetValue (line 88) | new T GetValue(int index);
FILE: src/Octonica.ClickHouseClient/IClickHouseTableColumnDispatcher.cs
type IClickHouseTableColumnDispatcher (line 24) | public interface IClickHouseTableColumnDispatcher<out TRes>
method Dispatch (line 32) | TRes Dispatch<T>(IClickHouseTableColumn<T> column);
FILE: src/Octonica.ClickHouseClient/IClickHouseTableProvider.cs
type IClickHouseTableProvider (line 26) | public interface IClickHouseTableProvider
method GetColumnDescriptor (line 48) | IClickHouseColumnDescriptor GetColumnDescriptor(int index);
method GetColumn (line 60) | object GetColumn(int index);
FILE: src/Octonica.ClickHouseClient/Protocol/BlockFieldCodes.cs
class BlockFieldCodes (line 23) | internal static class BlockFieldCodes
FILE: src/Octonica.ClickHouseClient/Protocol/BlockHeader.cs
class BlockHeader (line 22) | internal class BlockHeader
method BlockHeader (line 32) | public BlockHeader(string? tableName, ReadOnlyCollection<ColumnInfo>? ...
FILE: src/Octonica.ClickHouseClient/Protocol/CityHash.cs
class CityHash (line 39) | internal static class CityHash
method UNALIGNED_LOAD64 (line 41) | private static UInt64 UNALIGNED_LOAD64(ReadOnlySequence<byte> p)
method UNALIGNED_LOAD32 (line 51) | private static UInt32 UNALIGNED_LOAD32(ReadOnlySequence<byte> p)
method Fetch64 (line 61) | [MethodImpl(MethodImplOptions.AggressiveInlining)]
method Fetch32 (line 67) | [MethodImpl(MethodImplOptions.AggressiveInlining)]
method Rotate (line 81) | [MethodImpl(MethodImplOptions.AggressiveInlining)]
method RotateByAtLeast1 (line 91) | [MethodImpl(MethodImplOptions.AggressiveInlining)]
method ShiftMix (line 97) | [MethodImpl(MethodImplOptions.AggressiveInlining)]
method HashLen16 (line 103) | [MethodImpl(MethodImplOptions.AggressiveInlining)]
method Hash128to64 (line 111) | private static UInt64 Hash128to64(UInt128 x)
method HashLen0to16 (line 135) | private static UInt64 HashLen0to16(ReadOnlySequence<byte> s)
method WeakHashLen32WithSeeds (line 171) | private static (UInt64 first, UInt64 second) WeakHashLen32WithSeeds(
method WeakHashLen32WithSeeds (line 189) | private static (UInt64 first, UInt64 second) WeakHashLen32WithSeeds(
method CityMurmur (line 205) | private static UInt128 CityMurmur(ReadOnlySequence<byte> s, UInt128 seed)
method CityHash128WithSeed (line 253) | public static UInt128 CityHash128WithSeed(ReadOnlySequence<byte> s, UI...
method CityHash128 (line 338) | public static UInt128 CityHash128(ReadOnlySequence<byte> s)
type UInt128 (line 366) | internal readonly struct UInt128
method UInt128 (line 371) | public UInt128(ulong high, ulong low)
FILE: src/Octonica.ClickHouseClient/Protocol/ClickHouseEmptyTableWriter.cs
class ClickHouseEmptyTableWriter (line 22) | internal class ClickHouseEmptyTableWriter : IClickHouseTableWriter
method ClickHouseEmptyTableWriter (line 32) | private ClickHouseEmptyTableWriter()
FILE: src/Octonica.ClickHouseClient/Protocol/ClickHouseParameterWriter.cs
class ClickHouseParameterWriter (line 25) | internal abstract class ClickHouseParameterWriter : IClickHouseParameter...
method Write (line 29) | public abstract int Write(Memory<byte> buffer);
method Interpolate (line 31) | public abstract StringBuilder Interpolate(StringBuilder queryBuilder);
method Interpolate (line 33) | public abstract StringBuilder Interpolate(StringBuilder queryBuilder, ...
method Dispatch (line 35) | public static ClickHouseParameterWriter Dispatch(IClickHouseColumnType...
class Dispatcher (line 41) | private sealed class Dispatcher : ITypeDispatcher<ClickHouseParameterW...
method Dispatcher (line 46) | public Dispatcher(IClickHouseColumnTypeInfo typeInfo, object? value)
method Dispatch (line 52) | public ClickHouseParameterWriter Dispatch<T>()
method Dispatch (line 62) | public ClickHouseParameterWriter Dispatch()
method ClickHouseParameterWriter (line 77) | public ClickHouseParameterWriter(IClickHouseParameterWriter<T> writer,...
method Interpolate (line 84) | public override StringBuilder Interpolate(StringBuilder queryBuilder)
method Interpolate (line 89) | public override StringBuilder Interpolate(StringBuilder queryBuilder, ...
method Write (line 100) | public override int Write(Memory<byte> buffer)
class ClickHouseParameterWriter (line 69) | internal sealed class ClickHouseParameterWriter<T> : ClickHouseParameter...
method Write (line 29) | public abstract int Write(Memory<byte> buffer);
method Interpolate (line 31) | public abstract StringBuilder Interpolate(StringBuilder queryBuilder);
method Interpolate (line 33) | public abstract StringBuilder Interpolate(StringBuilder queryBuilder, ...
method Dispatch (line 35) | public static ClickHouseParameterWriter Dispatch(IClickHouseColumnType...
class Dispatcher (line 41) | private sealed class Dispatcher : ITypeDispatcher<ClickHouseParameterW...
method Dispatcher (line 46) | public Dispatcher(IClickHouseColumnTypeInfo typeInfo, object? value)
method Dispatch (line 52) | public ClickHouseParameterWriter Dispatch<T>()
method Dispatch (line 62) | public ClickHouseParameterWriter Dispatch()
method ClickHouseParameterWriter (line 77) | public ClickHouseParameterWriter(IClickHouseParameterWriter<T> writer,...
method Interpolate (line 84) | public override StringBuilder Interpolate(StringBuilder queryBuilder)
method Interpolate (line 89) | public override StringBuilder Interpolate(StringBuilder queryBuilder, ...
method Write (line 100) | public override int Write(Memory<byte> buffer)
FILE: src/Octonica.ClickHouseClient/Protocol/ClickHouseProtocolRevisions.cs
class ClickHouseProtocolRevisions (line 23) | public static class ClickHouseProtocolRevisions
FILE: src/Octonica.ClickHouseClient/Protocol/ClickHouseSyntaxHelper.cs
class ClickHouseSyntaxHelper (line 25) | internal static class ClickHouseSyntaxHelper
method TryGetUnescapedCharacter (line 31) | private static bool TryGetUnescapedCharacter(char ch, out char unescap...
method GetIdentifierLiteralLength (line 46) | public static int GetIdentifierLiteralLength(string str, int startIndex)
method GetIdentifierLiteralLength (line 51) | public static int GetIdentifierLiteralLength(ReadOnlySpan<char> str)
method GetSingleQuoteStringLength (line 83) | public static int GetSingleQuoteStringLength(string str, int startIndex)
method GetSingleQuoteStringLength (line 88) | public static int GetSingleQuoteStringLength(ReadOnlySpan<char> str)
method GetQuotedTokenLength (line 93) | public static int GetQuotedTokenLength(ReadOnlySpan<char> str, char qu...
method GetIdentifier (line 119) | public static string GetIdentifier(ReadOnlySpan<char> identifierLiteral)
method GetSingleQuoteString (line 155) | public static string GetSingleQuoteString(ReadOnlySpan<char> stringToken)
method TryParseQuotedToken (line 163) | private static bool TryParseQuotedToken(ReadOnlySpan<char> token, char...
FILE: src/Octonica.ClickHouseClient/Protocol/ClientHelloMessage.cs
class ClientHelloMessage (line 22) | internal class ClientHelloMessage : IClientMessage
method ClientHelloMessage (line 40) | private ClientHelloMessage(Builder builder)
method Write (line 51) | public void Write(ClickHouseBinaryProtocolWriter writer)
method WriteAddendum (line 65) | public void WriteAddendum(ClickHouseBinaryProtocolWriter writer)
class Builder (line 70) | internal class Builder
method Build (line 107) | public ClientHelloMessage Build()
FILE: src/Octonica.ClickHouseClient/Protocol/ClientMessageCode.cs
type ClientMessageCode (line 20) | internal enum ClientMessageCode
FILE: src/Octonica.ClickHouseClient/Protocol/ClientQueryMessage.cs
class ClientQueryMessage (line 24) | internal sealed class ClientQueryMessage : IClientMessage
method ClientQueryMessage (line 51) | private ClientQueryMessage(Builder builder)
method Write (line 66) | public void Write(ClickHouseBinaryProtocolWriter writer)
class Builder (line 194) | public class Builder
method Build (line 251) | public ClientQueryMessage Build()
FILE: src/Octonica.ClickHouseClient/Protocol/ColumnInfo.cs
class ColumnInfo (line 22) | internal class ColumnInfo
method ColumnInfo (line 28) | public ColumnInfo(string name, IClickHouseColumnTypeInfo typeInfo)
FILE: src/Octonica.ClickHouseClient/Protocol/CompressionAlgorithm.cs
type CompressionAlgorithm (line 20) | internal enum CompressionAlgorithm
FILE: src/Octonica.ClickHouseClient/Protocol/CompressionDecoderBase.cs
class CompressionDecoderBase (line 25) | internal abstract class CompressionDecoderBase : IDisposable
method CompressionDecoderBase (line 44) | protected CompressionDecoderBase(int bufferSize)
method ReadHeader (line 49) | public int ReadHeader(ReadOnlySequence<byte> sequence)
method Read (line 104) | public ReadOnlySequence<byte> Read()
method AdvanceReader (line 112) | public void AdvanceReader(SequencePosition position)
method ConsumeNext (line 133) | public int ConsumeNext(ReadOnlySequence<byte> sequence)
method Reset (line 157) | public void Reset()
method Decode (line 165) | protected abstract int Decode(ReadOnlySpan<byte> source, Span<byte> ta...
method Dispose (line 167) | public abstract void Dispose();
method GetBufferSize (line 169) | private int GetBufferSize(int minRequiredSize)
FILE: src/Octonica.ClickHouseClient/Protocol/CompressionEncoderBase.cs
class CompressionEncoderBase (line 32) | internal abstract class CompressionEncoderBase: IDisposable
method CompressionEncoderBase (line 44) | protected CompressionEncoderBase(int bufferSize)
method GetSpan (line 49) | public Span<byte> GetSpan(int sizeHint)
method GetMemory (line 55) | public Memory<byte> GetMemory(int sizeHint)
method GetMemory (line 61) | public Memory<byte> GetMemory()
method AcquireBuffer (line 66) | private (byte[] buffer, int position) AcquireBuffer(int sizeHint)
method Advance (line 87) | public void Advance(int bytes)
method Reset (line 113) | public void Reset()
method Complete (line 124) | public void Complete(ReadWriteBuffer pipeWriter)
method ConsumeNext (line 285) | protected abstract int ConsumeNext(byte[] source, int offset, int leng...
method EncodeNext (line 287) | protected abstract int EncodeNext(byte[] target, int offset, int length);
method EncodeFinal (line 289) | protected abstract int EncodeFinal(byte[] target, int offset, int leng...
method Dispose (line 291) | public abstract void Dispose();
FILE: src/Octonica.ClickHouseClient/Protocol/IClickHouseColumnReader.cs
type IClickHouseColumnReader (line 23) | public interface IClickHouseColumnReader : IClickHouseColumnReaderBase
method EndRead (line 30) | IClickHouseTableColumn EndRead(ClickHouseColumnSettings? settings);
FILE: src/Octonica.ClickHouseClient/Protocol/IClickHouseColumnReaderBase.cs
type IClickHouseColumnReaderBase (line 25) | public interface IClickHouseColumnReaderBase
method ReadNext (line 32) | SequenceSize ReadNext(ReadOnlySequence<byte> sequence);
method ReadPrefix (line 43) | SequenceSize ReadPrefix(ReadOnlySequence<byte> sequence) => new Sequen...
FILE: src/Octonica.ClickHouseClient/Protocol/IClickHouseColumnWriter.cs
type IClickHouseColumnWriter (line 25) | public interface IClickHouseColumnWriter
method WriteNext (line 42) | SequenceSize WriteNext(Span<byte> writeTo);
method WritePrefix (line 53) | SequenceSize WritePrefix(Span<byte> writeTo) => new SequenceSize(0, 1);
FILE: src/Octonica.ClickHouseClient/Protocol/IClickHouseColumnWriterFactory.cs
type IClickHouseColumnWriterFactory (line 20) | internal interface IClickHouseColumnWriterFactory
method Create (line 22) | IClickHouseColumnWriter Create(int offset, int length);
FILE: src/Octonica.ClickHouseClient/Protocol/IClickHouseParameterValueWriter.cs
type IClickHouseParameterValueWriter (line 28) | public interface IClickHouseParameterValueWriter
method Write (line 41) | int Write(Memory<byte> buffer);
FILE: src/Octonica.ClickHouseClient/Protocol/IClickHouseParameterWriter.cs
type IClickHouseParameterWriter (line 32) | public interface IClickHouseParameterWriter<in T>
method TryCreateParameterValueWriter (line 44) | bool TryCreateParameterValueWriter(T value, bool isNested, [NotNullWhe...
method Interpolate (line 52) | StringBuilder Interpolate(StringBuilder queryBuilder, T value);
method Interpolate (line 66) | StringBuilder Interpolate(StringBuilder queryBuilder, IClickHouseTypeI...
FILE: src/Octonica.ClickHouseClient/Protocol/IClickHouseTableWriter.cs
type IClickHouseTableWriter (line 22) | internal interface IClickHouseTableWriter
FILE: src/Octonica.ClickHouseClient/Protocol/IClientMessage.cs
type IClientMessage (line 20) | internal interface IClientMessage
method Write (line 24) | void Write(ClickHouseBinaryProtocolWriter writer);
FILE: src/Octonica.ClickHouseClient/Protocol/IServerMessage.cs
type IServerMessage (line 20) | internal interface IServerMessage
FILE: src/Octonica.ClickHouseClient/Protocol/Lz4CompressionDecoder.cs
class Lz4CompressionDecoder (line 23) | internal sealed class Lz4CompressionDecoder : CompressionDecoderBase
method Lz4CompressionDecoder (line 29) | public Lz4CompressionDecoder(int bufferSize)
method Decode (line 34) | protected override int Decode(ReadOnlySpan<byte> source, Span<byte> ta...
method Dispose (line 39) | public override void Dispose()
FILE: src/Octonica.ClickHouseClient/Protocol/Lz4CompressionEncoder.cs
class Lz4CompressionEncoder (line 24) | internal sealed class Lz4CompressionEncoder : CompressionEncoderBase
method Lz4CompressionEncoder (line 36) | public Lz4CompressionEncoder(int bufferSize, int blockSize)
method ConsumeNext (line 43) | protected override int ConsumeNext(byte[] source, int offset, int length)
method EncodeNext (line 49) | protected override int EncodeNext(byte[] target, int offset, int length)
method EncodeFinal (line 67) | protected override int EncodeFinal(byte[] target, int offset, int length)
method Dispose (line 85) | public override void Dispose()
FILE: src/Octonica.ClickHouseClient/Protocol/QueryKind.cs
type QueryKind (line 20) | internal enum QueryKind
FILE: src/Octonica.ClickHouseClient/Protocol/SequenceSize.cs
type SequenceSize (line 23) | public readonly struct SequenceSize
method SequenceSize (line 46) | public SequenceSize(int bytes, int elements)
method AddBytes (line 57) | public SequenceSize AddBytes(int bytes)
method AddElements (line 67) | public SequenceSize AddElements(int elements)
method Add (line 78) | public SequenceSize Add(SequenceSize size)
FILE: src/Octonica.ClickHouseClient/Protocol/ServerDataMessage.cs
class ServerDataMessage (line 23) | internal sealed class ServerDataMessage : IServerMessage
method ServerDataMessage (line 29) | private ServerDataMessage(ServerMessageCode messageCode, string? tempT...
method Read (line 35) | public static async ValueTask<ServerDataMessage> Read(ClickHouseBinary...
FILE: src/Octonica.ClickHouseClient/Protocol/ServerEndOfStreamMessage.cs
class ServerEndOfStreamMessage (line 20) | internal sealed class ServerEndOfStreamMessage : IServerMessage
method ServerEndOfStreamMessage (line 26) | private ServerEndOfStreamMessage()
FILE: src/Octonica.ClickHouseClient/Protocol/ServerErrorMessage.cs
class ServerErrorMessage (line 25) | internal sealed class ServerErrorMessage : IServerMessage
method ServerErrorMessage (line 31) | private ServerErrorMessage(ClickHouseServerException exception)
method Read (line 36) | public static async ValueTask<ServerErrorMessage> Read(ClickHouseBinar...
FILE: src/Octonica.ClickHouseClient/Protocol/ServerHelloMessage.cs
class ServerHelloMessage (line 26) | internal sealed class ServerHelloMessage : IServerMessage
method ServerHelloMessage (line 32) | private ServerHelloMessage(ClickHouseServerInfo serverInfo)
method Read (line 37) | public static async Task<ServerHelloMessage> Read(ClickHouseBinaryProt...
FILE: src/Octonica.ClickHouseClient/Protocol/ServerMessageCode.cs
type ServerMessageCode (line 20) | internal enum ServerMessageCode
FILE: src/Octonica.ClickHouseClient/Protocol/ServerPongMessage.cs
class ServerPongMessage (line 20) | internal sealed class ServerPongMessage : IServerMessage
method ServerPongMessage (line 26) | private ServerPongMessage()
FILE: src/Octonica.ClickHouseClient/Protocol/ServerProfileInfoMessage.cs
class ServerProfileInfoMessage (line 23) | internal sealed class ServerProfileInfoMessage : IServerMessage
method ServerProfileInfoMessage (line 39) | private ServerProfileInfoMessage(ulong rows, ulong blocks, ulong bytes...
method Read (line 49) | public static async ValueTask<ServerProfileInfoMessage> Read(ClickHous...
FILE: src/Octonica.ClickHouseClient/Protocol/ServerProgressMessage.cs
class ServerProgressMessage (line 23) | internal sealed class ServerProgressMessage : IServerMessage
method ServerProgressMessage (line 29) | private ServerProgressMessage(ulong rows, ulong bytes, ulong totalRows...
method Read (line 34) | public static async ValueTask<ServerProgressMessage> Read(ClickHouseBi...
FILE: src/Octonica.ClickHouseClient/Protocol/ServerTableColumnsMessage.cs
class ServerTableColumnsMessage (line 23) | internal sealed class ServerTableColumnsMessage : IServerMessage
method ServerTableColumnsMessage (line 29) | private ServerTableColumnsMessage(string columns)
method Read (line 34) | public static async ValueTask<ServerTableColumnsMessage> Read(ClickHou...
FILE: src/Octonica.ClickHouseClient/Protocol/ServerTimeZoneUpdateMessage.cs
class ServerTimeZoneUpdateMessage (line 23) | internal sealed class ServerTimeZoneUpdateMessage : IServerMessage
method ServerTimeZoneUpdateMessage (line 29) | public ServerTimeZoneUpdateMessage(string timezone)
method Read (line 34) | public static async ValueTask<ServerTimeZoneUpdateMessage> Read(ClickH...
FILE: src/Octonica.ClickHouseClient/Protocol/StateCodes.cs
class StateCodes (line 20) | internal static class StateCodes
FILE: src/Octonica.ClickHouseClient/Protocol/UnknownServerMessage.cs
class UnknownServerMessage (line 20) | internal sealed class UnknownServerMessage : IServerMessage
method UnknownServerMessage (line 24) | public UnknownServerMessage(ServerMessageCode messageCode)
FILE: src/Octonica.ClickHouseClient/Types/ArrayTableColumn.cs
class ArrayTableColumn (line 25) | internal sealed class ArrayTableColumn : IClickHouseTableColumn
method ArrayTableColumn (line 32) | public ArrayTableColumn(IClickHouseTableColumn column, List<(int offse...
method IsNull (line 38) | public bool IsNull(int index)
method GetValue (line 43) | public object GetValue(int index)
method TryReinterpret (line 61) | public IClickHouseTableColumn<T>? TryReinterpret<T>()
method TryDipatch (line 71) | bool IClickHouseTableColumn.TryDipatch<T>(IClickHouseTableColumnDispat...
method ArrayTableColumn (line 87) | public ArrayTableColumn(IClickHouseTableColumn<TElement> column, List<...
method IsNull (line 94) | public bool IsNull(int index)
method GetValue (line 99) | public TElement[] GetValue(int index)
method TryReinterpret (line 112) | public IClickHouseTableColumn<T>? TryReinterpret<T>()
method TryReinterpretAsArray (line 122) | IClickHouseArrayTableColumn<T>? IClickHouseTableColumn.TryReinterpretA...
method GetValue (line 131) | object IClickHouseTableColumn.GetValue(int index)
method CopyTo (line 136) | public int CopyTo(int index, Span<TElement> buffer, int dataOffset)
method TryDipatch (line 149) | bool IClickHouseTableColumn.TryDipatch<T>(IClickHouseTableColumnDispat...
class ArrayTableColumn (line 78) | internal sealed class ArrayTableColumn<TElement> : IClickHouseTableColum...
method ArrayTableColumn (line 32) | public ArrayTableColumn(IClickHouseTableColumn column, List<(int offse...
method IsNull (line 38) | public bool IsNull(int index)
method GetValue (line 43) | public object GetValue(int index)
method TryReinterpret (line 61) | public IClickHouseTableColumn<T>? TryReinterpret<T>()
method TryDipatch (line 71) | bool IClickHouseTableColumn.TryDipatch<T>(IClickHouseTableColumnDispat...
method ArrayTableColumn (line 87) | public ArrayTableColumn(IClickHouseTableColumn<TElement> column, List<...
method IsNull (line 94) | public bool IsNull(int index)
method GetValue (line 99) | public TElement[] GetValue(int index)
method TryReinterpret (line 112) | public IClickHouseTableColumn<T>? TryReinterpret<T>()
method TryReinterpretAsArray (line 122) | IClickHouseArrayTableColumn<T>? IClickHouseTableColumn.TryReinterpretA...
method GetValue (line 131) | object IClickHouseTableColumn.GetValue(int index)
method CopyTo (line 136) | public int CopyTo(int index, Span<TElement> buffer, int dataOffset)
method TryDipatch (line 149) | bool IClickHouseTableColumn.TryDipatch<T>(IClickHouseTableColumnDispat...
class ArrayTableColumnTypeDispatcher (line 156) | internal sealed class ArrayTableColumnTypeDispatcher : ITypeDispatcher<I...
method ArrayTableColumnTypeDispatcher (line 161) | public ArrayTableColumnTypeDispatcher(IClickHouseTableColumn column, L...
method Dispatch (line 167) | public IClickHouseTableColumn? Dispatch<T>()
FILE: src/Octonica.ClickHouseClient/Types/ArrayTypeInfo.cs
class ArrayTypeInfo (line 33) | internal sealed class ArrayTypeInfo : IClickHouseColumnTypeInfo
method ArrayTypeInfo (line 43) | public ArrayTypeInfo()
method ArrayTypeInfo (line 48) | private ArrayTypeInfo(IClickHouseColumnTypeInfo elementTypeInfo)
method CreateColumnReader (line 54) | public IClickHouseColumnReader CreateColumnReader(int rowCount)
method CreateColumnReader (line 62) | IClickHouseColumnReader IClickHouseColumnTypeInfo.CreateColumnReader(i...
method CreateSkippingColumnReader (line 70) | public IClickHouseColumnReaderBase CreateSkippingColumnReader(int rowC...
method CreateSkippingColumnReader (line 78) | IClickHouseColumnReaderBase IClickHouseColumnTypeInfo.CreateSkippingCo...
method CreateColumnWriter (line 86) | public IClickHouseColumnWriter CreateColumnWriter<T>(string columnName...
method GetDetailedTypeInfo (line 171) | public IClickHouseColumnTypeInfo GetDetailedTypeInfo(List<ReadOnlyMemo...
method GetFieldType (line 180) | public Type GetFieldType()
method GetDbType (line 185) | public ClickHouseDbType GetDbType()
method GetGenericArgument (line 190) | public IClickHouseTypeInfo GetGenericArgument(int index)
method CreateParameterWriter (line 201) | public IClickHouseParameterWriter<T> CreateParameterWriter<T>()
class ArrayColumnReaderBase (line 277) | private abstract class ArrayColumnReaderBase<TElementColumnReader> : I...
method ArrayColumnReaderBase (line 295) | public ArrayColumnReaderBase(int rowCount, IClickHouseColumnTypeInfo...
method ReadPrefix (line 302) | SequenceSize IClickHouseColumnReaderBase.ReadPrefix(ReadOnlySequence...
method ReadNext (line 329) | SequenceSize IClickHouseColumnReaderBase.ReadNext(ReadOnlySequence<b...
method CreateElementColumnReader (line 409) | protected abstract TElementColumnReader CreateElementColumnReader(in...
class ArrayColumnReader (line 412) | private sealed class ArrayColumnReader : ArrayColumnReaderBase<IClickH...
method ArrayColumnReader (line 414) | public ArrayColumnReader(int rowCount, IClickHouseColumnTypeInfo ele...
method CreateElementColumnReader (line 419) | protected override IClickHouseColumnReader CreateElementColumnReader...
method EndRead (line 424) | public IClickHouseTableColumn EndRead(ClickHouseColumnSettings? sett...
class ArraySkippingColumnReader (line 437) | private sealed class ArraySkippingColumnReader : ArrayColumnReaderBase...
method ArraySkippingColumnReader (line 439) | public ArraySkippingColumnReader(int rowCount, IClickHouseColumnType...
method CreateElementColumnReader (line 444) | protected override IClickHouseColumnReaderBase CreateElementColumnRe...
class ArrayColumnWriterDispatcher (line 450) | private sealed class ArrayColumnWriterDispatcher : ArrayColumnWriterDi...
method ArrayColumnWriterDispatcher (line 452) | public ArrayColumnWriterDispatcher(string columnName, object rows, C...
method ToList (line 457) | protected override ArrayLinearizedList<T> ToList<T>(object rows)
class MemoryColumnWriterDispatcher (line 463) | private sealed class MemoryColumnWriterDispatcher : ArrayColumnWriterD...
method MemoryColumnWriterDispatcher (line 465) | public MemoryColumnWriterDispatcher(string columnName, object rows, ...
method ToList (line 470) | protected override ArrayLinearizedList<T> ToList<T>(object rows)
class ReadOnlyColumnWriterDispatcher (line 476) | private sealed class ReadOnlyColumnWriterDispatcher : ArrayColumnWrite...
method ReadOnlyColumnWriterDispatcher (line 478) | public ReadOnlyColumnWriterDispatcher(string columnName, object rows...
method ToList (line 483) | protected override ArrayLinearizedList<T> ToList<T>(object rows)
class ArrayColumnWriterDispatcherBase (line 489) | private abstract class ArrayColumnWriterDispatcherBase : ITypeDispatch...
method ArrayColumnWriterDispatcherBase (line 496) | protected ArrayColumnWriterDispatcherBase(string columnName, object ...
method Dispatch (line 504) | public IClickHouseColumnWriter Dispatch<T>()
method ToList (line 512) | protected abstract ArrayLinearizedList<T> ToList<T>(object rows);
class MultiDimensionalArrayColumnWriterDispatcher (line 515) | private sealed class MultiDimensionalArrayColumnWriterDispatcher : ITy...
method MultiDimensionalArrayColumnWriterDispatcher (line 523) | public MultiDimensionalArrayColumnWriterDispatcher(
method Dispatch (line 537) | public IClickHouseColumnWriter Dispatch<T>()
class ArrayColumnWriter (line 547) | private sealed class ArrayColumnWriter<T> : IClickHouseColumnWriter
method ArrayColumnWriter (line 560) | public ArrayColumnWriter(string columnType, ArrayLinearizedList<T> r...
method WritePrefix (line 568) | SequenceSize IClickHouseColumnWriter.WritePrefix(Span<byte> writeTo)
method WriteNext (line 573) | public SequenceSize WriteNext(Span<byte> writeTo)
class ArrayLinearizedList (line 611) | private sealed class ArrayLinearizedList<T> : IReadOnlyList<T>
method ArrayLinearizedList (line 619) | public ArrayLinearizedList(ICollectionList<T> listOfLists)
method GetEnumerator (line 634) | public IEnumerator<T> GetEnumerator()
method GetEnumerator (line 639) | IEnumerator IEnumerable.GetEnumerator()
class ArrayTableColumnDipatcher (line 688) | private sealed class ArrayTableColumnDipatcher : IClickHouseTableColum...
method ArrayTableColumnDipatcher (line 692) | public ArrayTableColumnDipatcher(List<(int offset, int length)> ranges)
method Dispatch (line 697) | public IClickHouseTableColumn Dispatch<T>(IClickHouseTableColumn<T> ...
class ArrayParameterWriterDispatcher (line 703) | private sealed class ArrayParameterWriterDispatcher<TArray> : ITypeDis...
method ArrayParameterWriterDispatcher (line 709) | public ArrayParameterWriterDispatcher(ArrayTypeInfo arrayType, IClic...
method Dispatch (line 716) | public IClickHouseParameterWriter<TArray> Dispatch<T>()
class MultidimensionalArralParameterWriter (line 727) | private sealed class MultidimensionalArralParameterWriter<TArray, TEle...
method MultidimensionalArralParameterWriter (line 732) | public MultidimensionalArralParameterWriter(ArrayTypeInfo arrayType,...
method TryCreateParameterValueWriter (line 738) | public bool TryCreateParameterValueWriter(TArray value, bool isNeste...
method TryCreateElementWriters (line 754) | private bool TryCreateElementWriters(Array array, IEnumerator enumer...
method Interpolate (line 786) | public StringBuilder Interpolate(StringBuilder queryBuilder, TArray ...
method Interpolate (line 795) | private StringBuilder Interpolate(StringBuilder queryBuilder, Array ...
method Interpolate (line 827) | public StringBuilder Interpolate(StringBuilder queryBuilder, IClickH...
class ArrayParameterWriter (line 866) | private sealed class ArrayParameterWriter<TArray, TElement> : IClickHo...
method ArrayParameterWriter (line 871) | public ArrayParameterWriter(ArrayTypeInfo type, IClickHouseParameter...
method TryCreateParameterValueWriter (line 877) | public bool TryCreateParameterValueWriter(TArray value, bool isNeste...
method Interpolate (line 898) | public StringBuilder Interpolate(StringBuilder queryBuilder, TArray ...
method Interpolate (line 922) | public StringBuilder Interpolate(StringBuilder queryBuilder, IClickH...
class ArrayLiteralValueWriter (line 944) | private sealed class ArrayLiteralValueWriter : IClickHouseParameterVal...
method ArrayLiteralValueWriter (line 950) | public ArrayLiteralValueWriter(List<IClickHouseParameterValueWriter>...
method Write (line 959) | public int Write(Memory<byte> buffer)
FILE: src/Octonica.ClickHouseClient/Types/BigIntegerTableColumn.cs
class BigIntegerTableColumn (line 23) | internal sealed class BigIntegerTableColumn : IClickHouseTableColumn<Big...
method BigIntegerTableColumn (line 33) | public BigIntegerTableColumn(byte[] rawData, int rowCount, int element...
method GetValue (line 41) | public BigInteger GetValue(int index)
method GetValue (line 50) | object IClickHouseTableColumn.GetValue(int index)
method IsNull (line 55) | public bool IsNull(int index)
method TryReinterpret (line 60) | public IClickHouseTableColumn<T>? TryReinterpret<T>()
method TryDipatch (line 68) | bool IClickHouseTableColumn.TryDipatch<T>(IClickHouseTableColumnDispat...
FILE: src/Octonica.ClickHouseClient/Types/BigIntegerTypeInfoBase.cs
class BigIntegerTypeInfoBase (line 30) | internal abstract class BigIntegerTypeInfoBase : SimpleTypeInfo
method BigIntegerTypeInfoBase (line 35) | protected BigIntegerTypeInfoBase(string typeName, int elementByteSize,...
method CreateColumnReader (line 42) | public sealed override IClickHouseColumnReader CreateColumnReader(int ...
method CreateSkippingColumnReader (line 47) | public sealed override IClickHouseColumnReaderBase CreateSkippingColum...
method CreateColumnWriter (line 52) | public sealed override IClickHouseColumnWriter CreateColumnWriter<T>(s...
method CreateParameterWriter (line 94) | public override IClickHouseParameterWriter<T> CreateParameterWriter<T>()
method GetFieldType (line 154) | public sealed override Type GetFieldType()
class BigIntegerColumnReader (line 159) | private sealed class BigIntegerColumnReader : IClickHouseColumnReader
method BigIntegerColumnReader (line 167) | public BigIntegerColumnReader(int rowCount, int elementByteSize, boo...
method ReadNext (line 178) | public SequenceSize ReadNext(ReadOnlySequence<byte> sequence)
method EndRead (line 192) | public IClickHouseTableColumn EndRead(ClickHouseColumnSettings? sett...
class BigIntegerColumnWriter (line 198) | private sealed class BigIntegerColumnWriter : StructureWriterBase<BigI...
method BigIntegerColumnWriter (line 202) | public BigIntegerColumnWriter(string columnName, string columnType, ...
method WriteElement (line 208) | protected override void WriteElement(Span<byte> writeTo, in BigInteg...
FILE: src/Octonica.ClickHouseClient/Types/BoolTableColumn.cs
class BoolTableColumn (line 23) | internal sealed class BoolTableColumn : IClickHouseTableColumn<bool>
method BoolTableColumn (line 31) | public BoolTableColumn(ReadOnlyMemory<byte> buffer)
method GetValue (line 36) | object IClickHouseTableColumn.GetValue(int index)
method GetValue (line 41) | public bool GetValue(int index)
method IsNull (line 46) | public bool IsNull(int index)
method TryReinterpret (line 51) | public IClickHouseTableColumn<T>? TryReinterpret<T>()
method TryDipatch (line 62) | public bool TryDipatch<T>(IClickHouseTableColumnDispatcher<T> dispatch...
FILE: src/Octonica.ClickHouseClient/Types/BoolTypeInfo.cs
class BoolTypeInfo (line 26) | internal sealed class BoolTypeInfo : SimpleTypeInfo
method BoolTypeInfo (line 28) | public BoolTypeInfo()
method CreateColumnReader (line 33) | public override IClickHouseColumnReader CreateColumnReader(int rowCount)
method CreateSkippingColumnReader (line 38) | public override IClickHouseColumnReaderBase CreateSkippingColumnReader...
method CreateColumnWriter (line 43) | public override IClickHouseColumnWriter CreateColumnWriter<T>(string c...
method CreateParameterWriter (line 64) | public override IClickHouseParameterWriter<T> CreateParameterWriter<T>()
method GetDbType (line 81) | public override ClickHouseDbType GetDbType()
method GetFieldType (line 86) | public override Type GetFieldType()
class BoolReader (line 91) | private sealed class BoolReader : StructureReaderBase<byte, bool>
method BoolReader (line 95) | public BoolReader(int rowCount)
method ReadElement (line 100) | protected override byte ReadElement(ReadOnlySpan<byte> source)
method EndRead (line 105) | protected override IClickHouseTableColumn<bool> EndRead(ClickHouseCo...
class BoolWriter (line 111) | private sealed class BoolWriter : StructureWriterBase<bool, byte>
method BoolWriter (line 113) | public BoolWriter(string columnName, string columnType, IReadOnlyLis...
method Convert (line 118) | protected override byte Convert(bool value)
FILE: src/Octonica.ClickHouseClient/Types/ClickHouseColumnReinterpreter.cs
class ClickHouseColumnReinterpreter (line 26) | internal sealed class ClickHouseColumnReinterpreter : ITypeDispatcher<IC...
method ClickHouseColumnReinterpreter (line 30) | private ClickHouseColumnReinterpreter()
method Dispatch (line 34) | IClickHouseColumnReinterpreter ITypeDispatcher<IClickHouseColumnReinte...
method Create (line 39) | public static IClickHouseColumnReinterpreter Create(Type type)
method CreateDispatcher (line 44) | public static ClickhouseColumnReinterpreterDispatcher CreateDispatcher...
method Create (line 49) | public static IClickHouseColumnReinterpreter Create<T, TRes>(Func<T, T...
method GuardNull (line 87) | public static TValue GuardNull<TValue>(TValue? value)
method GuardNull (line 97) | [return: NotNull]
method Reinterpret (line 108) | public static IClickHouseTableColumn<TRes> Reinterpret<T, TRes>(IClick...
method ClickHouseColumnReinterpreter (line 158) | private ClickHouseColumnReinterpreter()
method TryReinterpret (line 162) | public IClickHouseTableColumn? TryReinterpret(IClickHouseTableColumn c...
method TryReinterpret (line 201) | public abstract IClickHouseTableColumn? TryReinterpret(IClickHouseTabl...
class ClickhouseColumnReinterpreterDispatcher (line 117) | internal sealed class ClickhouseColumnReinterpreterDispatcher : IClickHo...
method ClickhouseColumnReinterpreterDispatcher (line 121) | public ClickhouseColumnReinterpreterDispatcher(IConverterDispatcher co...
method Dispatch (line 126) | public IClickHouseColumnReinterpreter? Dispatch<T>(IClickHouseTableCol...
method Dispatch (line 131) | public IClickHouseColumnReinterpreter? Dispatch<TFrom>()
method Dispatch (line 136) | public IClickHouseColumnReinterpreter Dispatch<TFrom, TTo>(Func<TFrom,...
method DispatchNoConvert (line 144) | public IClickHouseColumnReinterpreter? DispatchNoConvert()
class ClickHouseColumnReinterpreter (line 150) | internal sealed class ClickHouseColumnReinterpreter<T> : IClickHouseColu...
method ClickHouseColumnReinterpreter (line 30) | private ClickHouseColumnReinterpreter()
method Dispatch (line 34) | IClickHouseColumnReinterpreter ITypeDispatcher<IClickHouseColumnReinte...
method Create (line 39) | public static IClickHouseColumnReinterpreter Create(Type type)
method CreateDispatcher (line 44) | public static ClickhouseColumnReinterpreterDispatcher CreateDispatcher...
method Create (line 49) | public static IClickHouseColumnReinterpreter Create<T, TRes>(Func<T, T...
method GuardNull (line 87) | public static TValue GuardNull<TValue>(TValue? value)
method GuardNull (line 97) | [return: NotNull]
method Reinterpret (line 108) | public static IClickHouseTableColumn<TRes> Reinterpret<T, TRes>(IClick...
method ClickHouseColumnReinterpreter (line 158) | private ClickHouseColumnReinterpreter()
method TryReinterpret (line 162) | public IClickHouseTableColumn? TryReinterpret(IClickHouseTableColumn c...
method TryReinterpret (line 201) | public abstract IClickHouseTableColumn? TryReinterpret(IClickHouseTabl...
class ClickHouseObjectColumnReinterpreter (line 168) | internal sealed class ClickHouseObjectColumnReinterpreter<T> : IClickHou...
method ClickHouseObjectColumnReinterpreter (line 176) | public ClickHouseObjectColumnReinterpreter(Func<object, T> convert)
method TryReinterpret (line 181) | public IClickHouseTableColumn? TryReinterpret(IClickHouseTableColumn c...
method Guard (line 189) | private static Func<object, T> Guard(Func<object, T> convert)
class ClickHouseColumnReinterpreter (line 195) | internal abstract class ClickHouseColumnReinterpreter<T, TRes> : IClickH...
method ClickHouseColumnReinterpreter (line 30) | private ClickHouseColumnReinterpreter()
method Dispatch (line 34) | IClickHouseColumnReinterpreter ITypeDispatcher<IClickHouseColumnReinte...
method Create (line 39) | public static IClickHouseColumnReinterpreter Create(Type type)
method CreateDispatcher (line 44) | public static ClickhouseColumnReinterpreterDispatcher CreateDispatcher...
method Create (line 49) | public static IClickHouseColumnReinterpreter Create<T, TRes>(Func<T, T...
method GuardNull (line 87) | public static TValue GuardNull<TValue>(TValue? value)
method GuardNull (line 97) | [return: NotNull]
method Reinterpret (line 108) | public static IClickHouseTableColumn<TRes> Reinterpret<T, TRes>(IClick...
method ClickHouseColumnReinterpreter (line 158) | private ClickHouseColumnReinterpreter()
method TryReinterpret (line 162) | public IClickHouseTableColumn? TryReinterpret(IClickHouseTableColumn c...
method TryReinterpret (line 201) | public abstract IClickHouseTableColumn? TryReinterpret(IClickHouseTabl...
class ClickHouseColumnObjToObjReinterpreter (line 204) | internal sealed class ClickHouseColumnObjToObjReinterpreter<T, TRes> : C...
method ClickHouseColumnObjToObjReinterpreter (line 210) | public ClickHouseColumnObjToObjReinterpreter(Func<T, TRes> convert)
method TryReinterpret (line 215) | public override IClickHouseTableColumn? TryReinterpret(IClickHouseTabl...
method Guard (line 233) | private static Func<T, TRes> Guard(Func<T, TRes> convert)
method GuardNullable (line 238) | private static Func<T, TRes> GuardNullable(Func<T, TRes> convert)
class ClickHouseColumnObjToStructReinterpreter (line 244) | internal sealed class ClickHouseColumnObjToStructReinterpreter<T, TRes> ...
method ClickHouseColumnObjToStructReinterpreter (line 251) | public ClickHouseColumnObjToStructReinterpreter(Func<T, TRes> convert)
method ClickHouseColumnObjToStructReinterpreter (line 256) | public ClickHouseColumnObjToStructReinterpreter(Func<T, TRes?> convert)
method TryReinterpret (line 261) | public override IClickHouseTableColumn? TryReinterpret(IClickHouseTabl...
method GetConvert (line 288) | private Func<T, TRes> GetConvert()
method Guard (line 298) | private static Func<T, TRes> Guard(Func<T, TRes?> convert)
method GuardNullable (line 303) | private static Func<T, TRes?> GuardNullable(Func<T, TRes?> convert)
class ClickHouseColumnStructToObjReinterpreter (line 309) | internal sealed class ClickHouseColumnStructToObjReinterpreter<T, TRes> ...
method ClickHouseColumnStructToObjReinterpreter (line 316) | public ClickHouseColumnStructToObjReinterpreter(Func<T, TRes> convert)
method ClickHouseColumnStructToObjReinterpreter (line 321) | public ClickHouseColumnStructToObjReinterpreter(Func<T?, TRes> convert)
method TryReinterpret (line 326) | public override IClickHouseTableColumn? TryReinterpret(IClickHouseTabl...
method GetConvert (line 356) | private Func<T, TRes> GetConvert()
method GetConvertNullable (line 366) | private Func<T?, TRes> GetConvertNullable()
method Guard (line 376) | private static Func<T, TRes> Guard(Func<T, TRes> convert)
method Guard (line 381) | private static Func<T, TRes> Guard(Func<T?, TRes> convert)
method GuardNullable (line 386) | private static Func<T?, TRes> GuardNullable(Func<T, TRes> convert)
method GuardNullable (line 391) | private static Func<T?, TRes> GuardNullable(Func<T?, TRes> convert)
class ClickHouseColumnStructToStructReinterpreter (line 397) | internal sealed class ClickHouseColumnStructToStructReinterpreter<T, TRe...
method ClickHouseColumnStructToStructReinterpreter (line 406) | public ClickHouseColumnStructToStructReinterpreter(Func<T?, TRes?> con...
method ClickHouseColumnStructToStructReinterpreter (line 411) | public ClickHouseColumnStructToStructReinterpreter(Func<T?, TRes> conv...
method ClickHouseColumnStructToStructReinterpreter (line 416) | public ClickHouseColumnStructToStructReinterpreter(Func<T, TRes?> conv...
method ClickHouseColumnStructToStructReinterpreter (line 421) | public ClickHouseColumnStructToStructReinterpreter(Func<T, TRes> convert)
method TryReinterpret (line 426) | public override IClickHouseTableColumn? TryReinterpret(IClickHouseTabl...
method GetConvert (line 456) | private Func<T, TRes> GetConvert()
method GetConvertNullable (line 470) | private Func<T?, TRes?> GetConvertNullable()
method Guard (line 484) | private static Func<T, TRes> Guard(Func<T?, TRes?> convert)
method Guard (line 489) | private static Func<T, TRes> Guard(Func<T, TRes?> convert)
method Guard (line 494) | private static Func<T, TRes> Guard(Func<T?, TRes> convert)
method GuardNullable (line 499) | public static Func<T?, TRes?> GuardNullable(Func<T?, TRes?> convert)
method GuardNullable (line 504) | public static Func<T?, TRes?> GuardNullable(Func<T?, TRes> convert)
method GuardNullable (line 509) | public static Func<T?, TRes?> GuardNullable(Func<T, TRes?> convert)
method GuardNullable (line 514) | public static Func<T?, TRes?> GuardNullable(Func<T, TRes> convert)
FILE: src/Octonica.ClickHouseClient/Types/ClickHouseColumnSerializationMode.cs
type ClickHouseColumnSerializationMode (line 24) | public enum ClickHouseColumnSerializationMode
FILE: src/Octonica.ClickHouseClient/Types/ClickHouseEnumConverter.cs
class ClickHouseEnumConverter (line 28) | public sealed class ClickHouseEnumConverter<TEnum> : IClickHouseEnumConv...
method ClickHouseEnumConverter (line 36) | public ClickHouseEnumConverter()
method Dispatch (line 47) | T IClickHouseEnumConverter.Dispatch<T>(IClickHouseEnumConverterDispatc...
method TryMap (line 59) | public bool TryMap(int value, string stringValue, out TEnum enumValue)
FILE: src/Octonica.ClickHouseClient/Types/ClickHouseTableColumnHelper.cs
class ClickHouseTableColumnHelper (line 22) | internal static class ClickHouseTableColumnHelper
method TryGetValueType (line 24) | public static Type? TryGetValueType(IClickHouseTableColumn column)
class ClickHouseTableColumnValueTypeDispatcher (line 32) | private sealed class ClickHouseTableColumnValueTypeDispatcher : IClick...
method ClickHouseTableColumnValueTypeDispatcher (line 36) | private ClickHouseTableColumnValueTypeDispatcher()
method Dispatch (line 40) | public Type Dispatch<T>(IClickHouseTableColumn<T> column)
FILE: src/Octonica.ClickHouseClient/Types/ClickHouseTypeInfoProvider.cs
class DefaultTypeInfoProvider (line 37) | [Obsolete(nameof(DefaultTypeInfoProvider) + " was renamed to " + nameof(...
method DefaultTypeInfoProvider (line 50) | private DefaultTypeInfoProvider()
method DefaultTypeInfoProvider (line 63) | [Obsolete(nameof(DefaultTypeInfoProvider) + " was renamed to " + nameo...
class ClickHouseTypeInfoProvider (line 76) | public class ClickHouseTypeInfoProvider : IClickHouseTypeInfoProvider
method ClickHouseTypeInfoProvider (line 85) | private ClickHouseTypeInfoProvider()
method ClickHouseTypeInfoProvider (line 95) | protected ClickHouseTypeInfoProvider(IEnumerable<IClickHouseColumnType...
method GetTypeInfo (line 104) | public IClickHouseColumnTypeInfo GetTypeInfo(string typeName)
method GetTypeInfo (line 115) | public IClickHouseColumnTypeInfo GetTypeInfo(ReadOnlyMemory<char> type...
method GetTypeInfo (line 123) | private IClickHouseColumnTypeInfo? GetTypeInfo(string baseTypeName, Li...
method ParseTypeName (line 134) | private static (ReadOnlyMemory<char> baseTypeName, List<ReadOnlyMemory...
method GetTypeInfo (line 224) | public IClickHouseColumnTypeInfo GetTypeInfo(IClickHouseColumnTypeDesc...
method GetTypeFromValue (line 406) | internal static IntermediateClickHouseTypeInfo GetTypeFromValue(Type v...
method GetTimeZoneCode (line 544) | [return: NotNullIfNotNull("timeZone")]
method Configure (line 554) | public IClickHouseTypeInfoProvider Configure(ClickHouseServerInfo serv...
method GetDefaultTypes (line 566) | protected static IEnumerable<IClickHouseColumnTypeInfo> GetDefaultTypes()
FILE: src/Octonica.ClickHouseClient/Types/CustomSerializationColumnReader.cs
class CustomSerializationColumnReader (line 27) | internal sealed class CustomSerializationColumnReader : IClickHouseColum...
method CustomSerializationColumnReader (line 39) | public CustomSerializationColumnReader(IClickHouseColumnTypeInfo typeI...
method EndRead (line 46) | public IClickHouseTableColumn EndRead(ClickHouseColumnSettings? settings)
method Dispatch (line 63) | IClickHouseTableColumn IClickHouseTableColumnDispatcher<IClickHouseTab...
method ReadNext (line 69) | public SequenceSize ReadNext(ReadOnlySequence<byte> sequence)
method ReadSparse (line 100) | private SequenceSize ReadSparse(ReadOnlySequence<byte> sequence)
FILE: src/Octonica.ClickHouseClient/Types/CustomSerializationSkippingColumnReader.cs
class CustomSerializationSkippingColumnReader (line 26) | internal sealed class CustomSerializationSkippingColumnReader : IClickHo...
method CustomSerializationSkippingColumnReader (line 37) | public CustomSerializationSkippingColumnReader(IClickHouseColumnTypeIn...
method ReadNext (line 44) | public SequenceSize ReadNext(ReadOnlySequence<byte> sequence)
method SkipSparse (line 75) | private SequenceSize SkipSparse(ReadOnlySequence<byte> sequence)
FILE: src/Octonica.ClickHouseClient/Types/Date32TableColumn.Net6.0.cs
class Date32TableColumn (line 24) | partial class Date32TableColumn : IClickHouseTableColumn<DateOnly>
method GetValue (line 32) | public DateOnly GetValue(int index)
method TryReinterpret (line 38) | public IClickHouseTableColumn<T>? TryReinterpret<T>()
FILE: src/Octonica.ClickHouseClient/Types/Date32TableColumn.NetCoreApp3.1.cs
class Date32TableColumn (line 24) | partial class Date32TableColumn : IClickHouseTableColumn<DateTime>
method GetValue (line 30) | public DateTime GetValue(int index)
method TryReinterpret (line 36) | public IClickHouseTableColumn<T>? TryReinterpret<T>()
FILE: src/Octonica.ClickHouseClient/Types/Date32TableColumn.cs
class Date32TableColumn (line 23) | internal sealed partial class Date32TableColumn
method Date32TableColumn (line 29) | public Date32TableColumn(ReadOnlyMemory<int> buffer)
method IsNull (line 34) | public bool IsNull(int index)
method GetValue (line 39) | object IClickHouseTableColumn.GetValue(int index)
method TryDipatch (line 44) | public bool TryDipatch<T>(IClickHouseTableColumnDispatcher<T> dispatch...
FILE: src/Octonica.ClickHouseClient/Types/Date32TypeInfo.Net6.0.cs
class Date32TypeInfo (line 32) | partial class Date32TypeInfo
method GetFieldType (line 39) | public override Type GetFieldType()
method CreateColumnWriter (line 44) | public override IClickHouseColumnWriter CreateColumnWriter<T>(string c...
method CreateParameterWriter (line 57) | public override IClickHouseParameterWriter<T> CreateParameterWriter<T>()
method DateOnlyToDays (line 73) | private static int DateOnlyToDays(DateOnly value)
class Date32Reader (line 85) | partial class Date32Reader : StructureReaderBase<int, DateOnly>
method EndRead (line 87) | protected override IClickHouseTableColumn<DateOnly> EndRead(ClickHou...
class Date32Writer (line 93) | partial class Date32Writer : StructureWriterBase<DateOnly, int>
method Date32Writer (line 95) | public Date32Writer(string columnName, string columnType, IReadOnlyL...
method Convert (line 100) | protected override int Convert(DateOnly value)
class DateOnlyParameterWriter (line 106) | private sealed class DateOnlyParameterWriter : IClickHouseParameterWri...
method DateOnlyParameterWriter (line 110) | public DateOnlyParameterWriter(Date32TypeInfo typeInfo)
method TryCreateParameterValueWriter (line 115) | public bool TryCreateParameterValueWriter(DateOnly value, bool isNes...
method Interpolate (line 125) | public StringBuilder Interpolate(StringBuilder queryBuilder, DateOnl...
method Interpolate (line 131) | public StringBuilder Interpolate(StringBuilder queryBuilder, IClickH...
method ValueToString (line 136) | [MethodImpl(MethodImplOptions.AggressiveInlining)]
FILE: src/Octonica.ClickHouseClient/Types/Date32TypeInfo.NetCoreApp3.1.cs
class Date32TypeInfo (line 27) | partial class Date32TypeInfo
method GetFieldType (line 29) | public override Type GetFieldType()
method CreateColumnWriter (line 34) | public override IClickHouseColumnWriter CreateColumnWriter<T>(string c...
method CreateParameterWriter (line 42) | public override IClickHouseParameterWriter<T> CreateParameterWriter<T>()
method DateTimeToDays (line 54) | private static int DateTimeToDays(DateTime value)
class Date32Reader (line 66) | partial class Date32Reader : StructureReaderBase<int, DateTime>
method EndRead (line 68) | protected override IClickHouseTableColumn<DateTime> EndRead(ClickHou...
class Date32Writer (line 74) | partial class Date32Writer : StructureWriterBase<DateTime, int>
method Date32Writer (line 76) | public Date32Writer(string columnName, string columnType, IReadOnlyL...
method Convert (line 81) | protected override int Convert(DateTime value)
FILE: src/Octonica.ClickHouseClient/Types/Date32TypeInfo.cs
class Date32TypeInfo (line 28) | internal sealed partial class Date32TypeInfo : SimpleTypeInfo
method Date32TypeInfo (line 39) | public Date32TypeInfo()
method CreateColumnReader (line 44) | public override IClickHouseColumnReader CreateColumnReader(int rowCount)
method CreateSkippingColumnReader (line 49) | public override IClickHouseColumnReaderBase CreateSkippingColumnReader...
method GetDbType (line 54) | public override ClickHouseDbType GetDbType()
class Date32Reader (line 59) | private sealed partial class Date32Reader
method Date32Reader (line 63) | public Date32Reader(int rowCount)
method ReadElement (line 68) | protected override int ReadElement(ReadOnlySpan<byte> source)
class Date32Writer (line 74) | private sealed partial class Date32Writer
class DateTimeParameterWriter (line 78) | private sealed class DateTimeParameterWriter : IClickHouseParameterWri...
method DateTimeParameterWriter (line 82) | public DateTimeParameterWriter(Date32TypeInfo typeInfo)
method TryCreateParameterValueWriter (line 87) | public bool TryCreateParameterValueWriter(DateTime value, bool isNes...
method Interpolate (line 94) | public StringBuilder Interpolate(StringBuilder queryBuilder, DateTim...
method Interpolate (line 100) | public StringBuilder Interpolate(StringBuilder queryBuilder, IClickH...
method ValueToString (line 105) | [MethodImpl(MethodImplOptions.AggressiveInlining)]
FILE: src/Octonica.ClickHouseClient/Types/DateOnlyTableColumn.cs
class DateOnlyTableColumn (line 24) | internal sealed class DateOnlyTableColumn : StructureTableColumn<DateOnly>
method DateOnlyTableColumn (line 26) | public DateOnlyTableColumn(ReadOnlyMemory<DateOnly> buffer)
method TryReinterpret (line 31) | public override IClickHouseTableColumn<T>? TryReinterpret<T>()
FILE: src/Octonica.ClickHouseClient/Types/DateTime64TableColumn.cs
class DateTime64TableColumn (line 22) | internal sealed class DateTime64TableColumn : IClickHouseTableColumn<Dat...
method DateTime64TableColumn (line 35) | static DateTime64TableColumn()
method DateTime64TableColumn (line 68) | public DateTime64TableColumn(ReadOnlyMemory<long> buffer, int precisio...
method IsNull (line 77) | public bool IsNull(int index)
method GetValue (line 82) | public DateTimeOffset GetValue(int index)
method TryReinterpret (line 109) | public IClickHouseTableColumn<T>? TryReinterpret<T>()
method TryDipatch (line 128) | bool IClickHouseTableColumn.TryDipatch<T>(IClickHouseTableColumnDispat...
method GetValue (line 134) | object IClickHouseTableColumn.GetValue(int index)
FILE: src/Octonica.ClickHouseClient/Types/DateTime64TypeInfo.cs
class DateTime64TypeInfo (line 31) | internal sealed class DateTime64TypeInfo : IClickHouseConfigurableTypeInfo
method DateTime64TypeInfo (line 56) | static DateTime64TypeInfo()
method DateTime64TypeInfo (line 102) | public DateTime64TypeInfo()
method DateTime64TypeInfo (line 107) | private DateTime64TypeInfo(int? precision, string? timeZoneCode, bool ...
method GetFieldType (line 138) | public Type GetFieldType()
method GetDbType (line 143) | public ClickHouseDbType GetDbType()
method GetGenericArgument (line 148) | public IClickHouseTypeInfo GetGenericArgument(int index)
method GetTypeArgument (line 153) | public object GetTypeArgument(int index)
method CreateColumnReader (line 177) | public IClickHouseColumnReader CreateColumnReader(int rowCount)
method CreateSkippingColumnReader (line 183) | public IClickHouseColumnReaderBase CreateSkippingColumnReader(int rowC...
method CreateColumnWriter (line 188) | public IClickHouseColumnWriter CreateColumnWriter<T>(string columnName...
method CreateParameterWriter (line 208) | public IClickHouseParameterWriter<T> CreateParameterWriter<T>()
method GetDetailedTypeInfo (line 225) | public IClickHouseColumnTypeInfo GetDetailedTypeInfo(List<ReadOnlyMemo...
method Configure (line 244) | public IClickHouseColumnTypeInfo Configure(ClickHouseServerInfo server...
method GetTimeZone (line 249) | private TimeZoneInfo GetTimeZone()
class DateTime64Reader (line 261) | private sealed class DateTime64Reader : StructureReaderBase<long, Date...
method DateTime64Reader (line 268) | public DateTime64Reader(int rowCount, int precision, TimeZoneInfo ti...
method ReadElement (line 275) | protected override long ReadElement(ReadOnlySpan<byte> source)
method EndRead (line 280) | protected override IClickHouseTableColumn<DateTimeOffset> EndRead(Cl...
class DateTimeWriter (line 286) | private sealed class DateTimeWriter : StructureWriterBase<DateTime, lo...
method DateTimeWriter (line 292) | public DateTimeWriter(string columnName, string columnType, int prec...
method Convert (line 300) | long IConverter<DateTime, long>.Convert(DateTime value) => Convert(v...
method Convert (line 302) | protected override long Convert(DateTime value)
method ScaleTicks (line 321) | [MethodImpl(MethodImplOptions.AggressiveInlining)]
class DateTimeOffsetWriter (line 338) | private sealed class DateTimeOffsetWriter : StructureWriterBase<DateTi...
method DateTimeOffsetWriter (line 344) | public DateTimeOffsetWriter(string columnName, string columnType, in...
method Convert (line 352) | long IConverter<DateTimeOffset, long>.Convert(DateTimeOffset value) ...
method Convert (line 354) | protected override long Convert(DateTimeOffset value)
class DateTime64ParameterWriter (line 376) | private sealed class DateTime64ParameterWriter<T> : IClickHouseParamet...
method DateTime64ParameterWriter (line 381) | public DateTime64ParameterWriter(DateTime64TypeInfo typeInfo, IConve...
method TryCreateParameterValueWriter (line 389) | public bool TryCreateParameterValueWriter(T value, bool isNested, [N...
method Interpolate (line 397) | public StringBuilder Interpolate(StringBuilder queryBuilder, T value)
method Interpolate (line 410) | public StringBuilder Interpolate(StringBuilder queryBuilder, IClickH...
method Convert (line 425) | private long Convert(T value)
FILE: src/Octonica.ClickHouseClient/Types/DateTimeTableColumn.cs
class DateTimeTableColumn (line 22) | internal sealed class DateTimeTableColumn : IClickHouseTableColumn<DateT...
method DateTimeTableColumn (line 31) | public DateTimeTableColumn(ReadOnlyMemory<uint> buffer, TimeZoneInfo t...
method IsNull (line 38) | public bool IsNull(int index)
method GetValue (line 43) | public DateTimeOffset GetValue(int index)
method TryReinterpret (line 54) | public IClickHouseTableColumn<T>? TryReinterpret<T>()
method TryDipatch (line 68) | bool IClickHouseTableColumn.TryDipatch<T>(IClickHouseTableColumnDispat...
method GetValue (line 74) | object IClickHouseTableColumn.GetValue(int index)
FILE: src/Octonica.ClickHouseClient/Types/DateTimeTypeInfo.cs
class DateTimeTypeInfo (line 29) | internal sealed class DateTimeTypeInfo : IClickHouseConfigurableTypeInfo
method DateTimeTypeInfo (line 48) | public DateTimeTypeInfo()
method DateTimeTypeInfo (line 53) | private DateTimeTypeInfo(string? timeZoneCode, bool explicitTimeZoneCode)
method CreateColumnReader (line 60) | public IClickHouseColumnReader CreateColumnReader(int rowCount)
method CreateSkippingColumnReader (line 66) | public IClickHouseColumnReaderBase CreateSkippingColumnReader(int rowC...
method CreateColumnWriter (line 71) | public IClickHouseColumnWriter CreateColumnWriter<T>(string columnName...
method CreateParameterWriter (line 88) | public IClickHouseParameterWriter<T> CreateParameterWriter<T>()
method GetDetailedTypeInfo (line 104) | public IClickHouseColumnTypeInfo GetDetailedTypeInfo(List<ReadOnlyMemo...
method GetFieldType (line 113) | public Type GetFieldType()
method GetDbType (line 118) | public ClickHouseDbType GetDbType()
method GetGenericArgument (line 123) | public IClickHouseTypeInfo GetGenericArgument(int index)
method GetTypeArgument (line 128) | public object GetTypeArgument(int index)
method Configure (line 139) | public IClickHouseColumnTypeInfo Configure(ClickHouseServerInfo server...
method GetTimeZone (line 144) | private TimeZoneInfo GetTimeZone()
class DateTimeReader (line 156) | private sealed class DateTimeReader : StructureReaderBase<uint, DateTi...
method DateTimeReader (line 162) | public DateTimeReader(int rowCount, TimeZoneInfo timeZone)
method ReadElement (line 168) | protected override uint ReadElement(ReadOnlySpan<byte> source)
method EndRead (line 173) | protected override IClickHouseTableColumn<DateTimeOffset> EndRead(Cl...
class DateTimeWriter (line 179) | private sealed class DateTimeWriter : StructureWriterBase<DateTime, ui...
method DateTimeWriter (line 183) | public DateTimeWriter(string columnName, string columnType, TimeZone...
method Convert (line 189) | uint IConverter<DateTime, uint>.Convert(DateTime value)
method Convert (line 194) | protected override uint Convert(DateTime value)
class DateTimeOffsetWriter (line 214) | private sealed class DateTimeOffsetWriter : StructureWriterBase<DateTi...
method DateTimeOffsetWriter (line 218) | public DateTimeOffsetWriter(string columnName, string columnType, Ti...
method Convert (line 224) | uint IConverter<DateTimeOffset, uint>.Convert(DateTimeOffset value)
method Convert (line 229) | protected override uint Convert(DateTimeOffset value)
class DateTimeParameterWriter (line 251) | private sealed class DateTimeParameterWriter<T> : IClickHouseParameter...
method DateTimeParameterWriter (line 256) | public DateTimeParameterWriter(DateTimeTypeInfo typeInfo, IConverter...
method TryCreateParameterValueWriter (line 262) | public bool TryCreateParameterValueWriter(T value, bool isNested, [N...
method Interpolate (line 270) | public StringBuilder Interpolate(StringBuilder queryBuilder, T value)
method Interpolate (line 278) | public StringBuilder Interpolate(StringBuilder queryBuilder, IClickH...
FILE: src/Octonica.ClickHouseClient/Types/DateTypeInfo.Net6.0.cs
class DateTypeInfo (line 32) | partial class DateTypeInfo
method CreateColumnWriter (line 37) | public override IClickHouseColumnWriter CreateColumnWriter<T>(string c...
method CreateParameterWriter (line 50) | public override IClickHouseParameterWriter<T> CreateParameterWriter<T>()
method GetFieldType (line 66) | public override Type GetFieldType()
method DateOnlyToDays (line 71) | private static ushort DateOnlyToDays(DateOnly value)
class DateReader (line 83) | partial class DateReader : StructureReaderBase<DateOnly>
method DateReader (line 85) | public DateReader(int rowCount)
method ReadElement (line 90) | protected override DateOnly ReadElement(ReadOnlySpan<byte> source)
method EndRead (line 99) | protected override IClickHouseTableColumn<DateOnly> EndRead(ClickHou...
class DateWriter (line 105) | partial class DateWriter : StructureWriterBase<DateOnly, ushort>
method DateWriter (line 107) | public DateWriter(string columnName, string columnType, IReadOnlyLis...
method Convert (line 112) | protected override ushort Convert(DateOnly value)
class DateOnlyParameterWriter (line 118) | private sealed class DateOnlyParameterWriter : IClickHouseParameterWri...
method DateOnlyParameterWriter (line 122) | public DateOnlyParameterWriter(DateTypeInfo typeInfo)
method TryCreateParameterValueWriter (line 127) | public bool TryCreateParameterValueWriter(DateOnly value, bool isNes...
method Interpolate (line 137) | public StringBuilder Interpolate(StringBuilder queryBuilder, DateOnl...
method Interpolate (line 143) | public StringBuilder Interpolate(StringBuilder queryBuilder, IClickH...
method ValueToString (line 148) | [MethodImpl(MethodImplOptions.AggressiveInlining)]
FILE: src/Octonica.ClickHouseClient/Types/DateTypeInfo.NetCoreApp3.1.cs
class DateTypeInfo (line 27) | partial class DateTypeInfo
method CreateColumnWriter (line 29) | public override IClickHouseColumnWriter CreateColumnWriter<T>(string c...
method CreateParameterWriter (line 37) | public override IClickHouseParameterWriter<T> CreateParameterWriter<T>()
method DateTimeToDays (line 49) | private static ushort DateTimeToDays(DateTime value)
method GetFieldType (line 61) | public override Type GetFieldType()
class DateReader (line 66) | partial class DateReader : StructureReaderBase<DateTime>
method DateReader (line 70) | public DateReader(int rowCount)
method ReadElement (line 75) | protected override DateTime ReadElement(ReadOnlySpan<byte> source)
class DateWriter (line 85) | partial class DateWriter : StructureWriterBase<DateTime, ushort>
method DateWriter (line 87) | public DateWriter(string columnName, string columnType, IReadOnlyLis...
method Convert (line 92) | protected override ushort Convert(DateTime value)
FILE: src/Octonica.ClickHouseClient/Types/DateTypeInfo.cs
class DateTypeInfo (line 28) | internal sealed partial class DateTypeInfo : SimpleTypeInfo
method DateTypeInfo (line 36) | public DateTypeInfo()
method CreateColumnReader (line 41) | public override IClickHouseColumnReader CreateColumnReader(int rowCount)
method CreateSkippingColumnReader (line 46) | public override IClickHouseColumnReaderBase CreateSkippingColumnReader...
method GetDbType (line 51) | public override ClickHouseDbType GetDbType()
class DateReader (line 56) | private sealed partial class DateReader
class DateWriter (line 60) | private sealed partial class DateWriter
class DateTimeParameterWriter (line 64) | private sealed class DateTimeParameterWriter : IClickHouseParameterWri...
method DateTimeParameterWriter (line 68) | public DateTimeParameterWriter(DateTypeInfo typeInfo)
method TryCreateParameterValueWriter (line 73) | public bool TryCreateParameterValueWriter(DateTime value, bool isNes...
method Interpolate (line 83) | public StringBuilder Interpolate(StringBuilder queryBuilder, DateTim...
method Interpolate (line 89) | public StringBuilder Interpolate(StringBuilder queryBuilder, IClickH...
method ValueToString (line 94) | [MethodImpl(MethodImplOptions.AggressiveInlining)]
FILE: src/Octonica.ClickHouseClient/Types/Decimal128TypeInfo.cs
class Decimal128TypeInfo (line 23) | internal sealed class Decimal128TypeInfo : DecimalTypeInfoBase
method Decimal128TypeInfo (line 29) | public Decimal128TypeInfo()
method Decimal128TypeInfo (line 34) | private Decimal128TypeInfo(string typeName, string complexTypeName, in...
method CloneWithOptions (line 39) | protected override DecimalTypeInfoBase CloneWithOptions(string complex...
method GetTypeArgument (line 47) | public override object GetTypeArgument(int index)
FILE: src/Octonica.ClickHouseClient/Types/Decimal32TypeInfo.cs
class Decimal32TypeInfo (line 23) | internal sealed class Decimal32TypeInfo : DecimalTypeInfoBase
method Decimal32TypeInfo (line 29) | public Decimal32TypeInfo()
method Decimal32TypeInfo (line 34) | private Decimal32TypeInfo(string typeName, string complexTypeName, int...
method CloneWithOptions (line 39) | protected override DecimalTypeInfoBase CloneWithOptions(string complex...
method GetTypeArgument (line 47) | public override object GetTypeArgument(int index)
FILE: src/Octonica.ClickHouseClient/Types/Decimal64TypeInfo.cs
class Decimal64TypeInfo (line 23) | internal sealed class Decimal64TypeInfo : DecimalTypeInfoBase
method Decimal64TypeInfo (line 29) | public Decimal64TypeInfo()
method Decimal64TypeInfo (line 34) | private Decimal64TypeInfo(string typeName, string complexTypeName, int...
method CloneWithOptions (line 39) | protected override DecimalTypeInfoBase CloneWithOptions(string complex...
method GetTypeArgument (line 47) | public override object GetTypeArgument(int index)
FILE: src/Octonica.ClickHouseClient/Types/DecimalTableColumn.cs
class DecimalTableColumn (line 22) | internal sealed class DecimalTableColumn : IClickHouseTableColumn<decimal>
method DecimalTableColumn (line 35) | public DecimalTableColumn(ReadOnlyMemory<uint> buffer, int elementSize...
method IsNull (line 45) | public bool IsNull(int index)
method GetValue (line 50) | public decimal GetValue(int index)
method GetValue (line 176) | object IClickHouseTableColumn.GetValue(int index)
method TryReinterpret (line 181) | public IClickHouseTableColumn<T>? TryReinterpret<T>()
method TryDipatch (line 189) | bool IClickHouseTableColumn.TryDipatch<T>(IClickHouseTableColumnDispat...
FILE: src/Octonica.ClickHouseClient/Types/DecimalTypeInfo.cs
class DecimalTypeInfo (line 22) | internal sealed class DecimalTypeInfo : DecimalTypeInfoBase
method DecimalTypeInfo (line 24) | public DecimalTypeInfo()
method DecimalTypeInfo (line 29) | private DecimalTypeInfo(string typeName, string complexTypeName, int p...
method CloneWithOptions (line 34) | protected override DecimalTypeInfoBase CloneWithOptions(string complex...
FILE: src/Octonica.ClickHouseClient/Types/DecimalTypeInfoBase.cs
class DecimalTypeInfoBase (line 33) | internal abstract class DecimalTypeInfoBase : IClickHouseColumnTypeInfo
method DecimalTypeInfoBase (line 48) | protected DecimalTypeInfoBase(string typeName)
method DecimalTypeInfoBase (line 54) | protected DecimalTypeInfoBase(string typeName, string complexTypeName,...
method CreateColumnReader (line 69) | public IClickHouseColumnReader CreateColumnReader(int rowCount)
method CreateSkippingColumnReader (line 86) | public IClickHouseColumnReaderBase CreateSkippingColumnReader(int rowC...
method CreateColumnWriter (line 103) | public IClickHouseColumnWriter CreateColumnWriter<T>(string columnName...
method CreateParameterWriter (line 143) | public IClickHouseParameterWriter<T> CreateParameterWriter<T>()
method GetDetailedTypeInfo (line 176) | public IClickHouseColumnTypeInfo GetDetailedTypeInfo(List<ReadOnlyMemo...
method GetFieldType (line 207) | public Type GetFieldType()
method GetDbType (line 212) | public ClickHouseDbType GetDbType()
method GetGenericArgument (line 217) | public IClickHouseTypeInfo GetGenericArgument(int index)
method GetTypeArgument (line 222) | public virtual object GetTypeArgument(int index)
method CloneWithOptions (line 251) | protected abstract DecimalTypeInfoBase CloneWithOptions(string complex...
method GetElementSize (line 253) | private static int GetElementSize(int precision)
class DecimalReader (line 264) | private sealed class DecimalReader : IClickHouseColumnReader
method DecimalReader (line 274) | public DecimalReader(int precision, int scale, int rowCount)
method ReadNext (line 282) | public SequenceSize ReadNext(ReadOnlySequence<byte> sequence)
method EndRead (line 300) | public IClickHouseTableColumn EndRead(ClickHouseColumnSettings? sett...
method EndReadInternal (line 305) | private DecimalTableColumn EndReadInternal()
class DecimalWriter (line 312) | private sealed class DecimalWriter : StructureWriterBase<decimal>
method DecimalWriter (line 321) | public DecimalWriter(string columnName, string columnType, int preci...
method WriteDecimal (line 327) | public void WriteDecimal(Span<byte> writeTo, decimal value)
method WriteElement (line 332) | protected override void WriteElement(Span<byte> writeTo, in decimal ...
class DecimalParameterWriter (line 501) | private sealed class DecimalParameterWriter<T> : IClickHouseParameterW...
method DecimalParameterWriter (line 507) | public DecimalParameterWriter(DecimalTypeInfoBase type, DecimalWrite...
method TryCreateParameterValueWriter (line 514) | public bool TryCreateParameterValueWriter(T value, bool isNested, [N...
method Interpolate (line 533) | public StringBuilder Interpolate(StringBuilder queryBuilder, T value)
method Interpolate (line 549) | public StringBuilder Interpolate(StringBuilder queryBuilder, IClickH...
method GetBytes (line 564) | private void GetBytes(T value, Span<byte> buffer)
FILE: src/Octonica.ClickHouseClient/Types/EmptyParameterValueWriter.cs
class EmptyParameterValueWriter (line 23) | internal sealed class EmptyParameterValueWriter : IClickHouseParameterVa...
method EmptyParameterValueWriter (line 29) | private EmptyParameterValueWriter()
method Write (line 33) | public int Write(Memory<byte> buffer)
FILE: src/Octonica.ClickHouseClient/Types/Enum16TypeInfo.cs
class Enum16TypeInfo (line 26) | internal sealed class Enum16TypeInfo : EnumTypeInfoBase<short>
method Enum16TypeInfo (line 28) | public Enum16TypeInfo()
method Enum16TypeInfo (line 33) | private Enum16TypeInfo(string typeName, string complexTypeName, IEnume...
method CreateColumnReader (line 38) | protected override EnumColumnReaderBase CreateColumnReader(StructureRe...
method CreateInternalSkippingColumnReader (line 43) | protected override SimpleSkippingColumnReader CreateInternalSkippingCo...
method CreateDetailedTypeInfo (line 48) | protected override IClickHouseColumnTypeInfo CreateDetailedTypeInfo(st...
method CreateInternalColumnReader (line 53) | protected override StructureReaderBase<short> CreateInternalColumnRead...
method CreateInternalColumnWriter (line 58) | protected override IClickHouseColumnWriter CreateInternalColumnWriter<...
method CreateParameterWriter (line 74) | public override IClickHouseParameterWriter<T> CreateParameterWriter<T>()
method TryParse (line 103) | protected override bool TryParse(ReadOnlySpan<char> text, out short va...
class EnumColumnReader (line 108) | private sealed class EnumColumnReader : EnumColumnReaderBase
method EnumColumnReader (line 110) | public EnumColumnReader(StructureReaderBase<short> internalReader, I...
method CreateColumnDispatcher (line 115) | protected override EnumTableColumnDispatcherBase CreateColumnDispatc...
class EnumTableColumnDispatcher (line 121) | private sealed class EnumTableColumnDispatcher : EnumTableColumnDispat...
method EnumTableColumnDispatcher (line 123) | public EnumTableColumnDispatcher(IClickHouseTableColumn<short> colum...
method TryMap (line 128) | protected override bool TryMap<TEnum>(IClickHouseEnumConverter<TEnum...
FILE: src/Octonica.ClickHouseClient/Types/Enum8TypeInfo.cs
class Enum8TypeInfo (line 25) | internal sealed class Enum8TypeInfo : EnumTypeInfoBase<sbyte>
method Enum8TypeInfo (line 27) | public Enum8TypeInfo()
method Enum8TypeInfo (line 32) | private Enum8TypeInfo(string typeName, string complexTypeName, IEnumer...
method CreateColumnReader (line 37) | protected override EnumColumnReaderBase CreateColumnReader(StructureRe...
method CreateDetailedTypeInfo (line 42) | protected override IClickHouseColumnTypeInfo CreateDetailedTypeInfo(st...
method CreateInternalColumnReader (line 47) | protected override StructureReaderBase<sbyte> CreateInternalColumnRead...
method CreateInternalSkippingColumnReader (line 52) | protected override SimpleSkippingColumnReader CreateInternalSkippingCo...
method CreateInternalColumnWriter (line 57) | protected override IClickHouseColumnWriter CreateInternalColumnWriter<...
method CreateParameterWriter (line 65) | public override IClickHouseParameterWriter<T> CreateParameterWriter<T>()
method TryParse (line 86) | protected override bool TryParse(ReadOnlySpan<char> text, out sbyte va...
class EnumColumnReader (line 91) | private sealed class EnumColumnReader : EnumColumnReaderBase
method EnumColumnReader (line 93) | public EnumColumnReader(StructureReaderBase<sbyte> internalReader, I...
method CreateColumnDispatcher (line 98) | protected override EnumTableColumnDispatcherBase CreateColumnDispatc...
class EnumTableColumnDispatcher (line 104) | private sealed class EnumTableColumnDispatcher : EnumTableColumnDispat...
method EnumTableColumnDispatcher (line 106) | public EnumTableColumnDispatcher(IClickHouseTableColumn<sbyte> colum...
method TryMap (line 111) | protected override bool TryMap<TEnum>(IClickHouseEnumConverter<TEnum...
FILE: src/Octonica.ClickHouseClient/Types/EnumTableColumn.cs
class EnumTableColumn (line 24) | internal sealed class EnumTableColumn<TKey> : IClickHouseTableColumn<str...
method EnumTableColumn (line 34) | public EnumTableColumn(IClickHouseTableColumn<TKey> internalColumn, IR...
method IsNull (line 45) | public bool IsNull(int index)
method GetValue (line 51) | public string GetValue(int index)
method GetValue (line 60) | object IClickHouseTableColumn.GetValue(int index)
method TryReinterpret (line 65) | public IClickHouseTableColumn<T>? TryReinterpret<T>()
method TryDipatch (line 74) | bool IClickHouseTableColumn.TryDipatch<T>(IClickHouseTableColumnDispat...
method EnumTableColumn (line 93) | public EnumTableColumn(IClickHouseTableColumn<TKey> internalColumn, IR...
method IsNull (line 106) | public bool IsNull(int index)
method GetValue (line 112) | public TEnum GetValue(int index)
method GetValue (line 126) | object IClickHouseTableColumn.GetValue(int index)
method TryReinterpret (line 131) | public IClickHouseTableColumn<T>? TryReinterpret<T>()
method TryDipatch (line 145) | bool IClickHouseTableColumn.TryDipatch<T>(IClickHouseTableColumnDispat...
class EnumTableColumn (line 81) | internal sealed class EnumTableColumn<TKey, TEnum> : IClickHouseTableCol...
method EnumTableColumn (line 34) | public EnumTableColumn(IClickHouseTableColumn<TKey> internalColumn, IR...
method IsNull (line 45) | public bool IsNull(int index)
method GetValue (line 51) | public string GetValue(int index)
method GetValue (line 60) | object IClickHouseTableColumn.GetValue(int index)
method TryReinterpret (line 65) | public IClickHouseTableColumn<T>? TryReinterpret<T>()
method TryDipatch (line 74) | bool IClickHouseTableColumn.TryDipatch<T>(IClickHouseTableColumnDispat...
method EnumTableColumn (line 93) | public EnumTableColumn(IClickHouseTableColumn<TKey> internalColumn, IR...
method IsNull (line 106) | public bool IsNull(int index)
method GetValue (line 112) | public TEnum GetValue(int index)
method GetValue (line 126) | object IClickHouseTableColumn.GetValue(int index)
method TryReinterpret (line 131) | public IClickHouseTableColumn<T>? TryReinterpret<T>()
method TryDipatch (line 145) | bool IClickHouseTableColumn.TryDipatch<T>(IClickHouseTableColumnDispat...
FILE: src/Octonica.ClickHouseClient/Types/EnumTypeInfoBase.cs
class EnumTypeInfoBase (line 30) | internal abstract class EnumTypeInfoBase<TValue> : IClickHouseColumnType...
method EnumTypeInfoBase (line 45) | protected EnumTypeInfoBase(string typeName)
method EnumTypeInfoBase (line 51) | protected EnumTypeInfoBase(string typeName, string complexTypeName, IE...
method GetFieldType (line 68) | public Type GetFieldType()
method GetDbType (line 73) | public ClickHouseDbType GetDbType()
method GetGenericArgument (line 78) | public IClickHouseTypeInfo GetGenericArgument(int index)
method GetTypeArgument (line 83) | public object GetTypeArgument(int index)
method CreateColumnReader (line 94) | public IClickHouseColumnReader CreateColumnReader(int rowCount)
method CreateSkippingColumnReader (line 103) | public IClickHouseColumnReaderBase CreateSkippingColumnReader(int rowC...
method CreateColumnReader (line 111) | protected abstract EnumColumnReaderBase CreateColumnReader(StructureRe...
method CreateColumnWriter (line 113) | public IClickHouseColumnWriter CreateColumnWriter<T>(string columnName...
method CreateParameterWriter (line 129) | public abstract IClickHouseParameterWriter<T> CreateParameterWriter<T>();
method GetDetailedTypeInfo (line 131) | public IClickHouseColumnTypeInfo GetDetailedTypeInfo(List<ReadOnlyMemo...
method CreateDetailedTypeInfo (line 165) | protected abstract IClickHouseColumnTypeInfo CreateDetailedTypeInfo(st...
method CreateInternalColumnReader (line 167) | protected abstract StructureReaderBase<TValue> CreateInternalColumnRea...
method CreateInternalSkippingColumnReader (line 169) | protected abstract SimpleSkippingColumnReader CreateInternalSkippingCo...
method CreateInternalColumnWriter (line 171) | protected abstract IClickHouseColumnWriter CreateInternalColumnWriter<...
method TryParse (line 173) | protected abstract bool TryParse(ReadOnlySpan<char> text, out TValue v...
class EnumColumnReaderBase (line 175) | protected abstract class EnumColumnReaderBase : IClickHouseColumnReader
method EnumColumnReaderBase (line 180) | public EnumColumnReaderBase(StructureReaderBase<TValue> internalRead...
method ReadNext (line 186) | public SequenceSize ReadNext(ReadOnlySequence<byte> sequence)
method EndRead (line 191) | public IClickHouseTableColumn EndRead(ClickHouseColumnSettings? sett...
method CreateColumnDispatcher (line 204) | protected abstract EnumTableColumnDispatcherBase CreateColumnDispatc...
class EnumTableColumnDispatcherBase (line 207) | protected abstract class EnumTableColumnDispatcherBase : IClickHouseEn...
method EnumTableColumnDispatcherBase (line 212) | public EnumTableColumnDispatcherBase(IClickHouseTableColumn<TValue> ...
method Dispatch (line 218) | public IClickHouseTableColumn Dispatch<TEnum>(IClickHouseEnumConvert...
method TryMap (line 231) | protected abstract bool TryMap<TEnum>(IClickHouseEnumConverter<TEnum...
class EnumParameterWriter (line 235) | protected sealed class EnumParameterWriter : IClickHouseParameterWrite...
method EnumParameterWriter (line 240) | public EnumParameterWriter(EnumTypeInfoBase<TValue> type)
method TryCreateParameterValueWriter (line 246) | public bool TryCreateParameterValueWriter(string value, bool isNeste...
method Interpolate (line 252) | public StringBuilder Interpolate(StringBuilder queryBuilder, string ...
method Interpolate (line 258) | public StringBuilder Interpolate(StringBuilder queryBuilder, IClickH...
method Convert (line 263) | private TValue Convert(string value)
FILE: src/Octonica.ClickHouseClient/Types/FixedStringDecodedCharArrayTableColumn.cs
class FixedStringDecodedCharArrayTableColumn (line 23) | internal sealed class FixedStringDecodedCharArrayTableColumn : FixedStri...
method FixedStringDecodedCharArrayTableColumn (line 27) | public FixedStringDecodedCharArrayTableColumn(Memory<byte> buffer, int...
method GetValue (line 32) | protected override char[] GetValue(Encoding encoding, ReadOnlySpan<byt...
FILE: src/Octonica.ClickHouseClient/Types/FixedStringDecodedTableColumn.cs
class FixedStringDecodedTableColumn (line 23) | internal sealed class FixedStringDecodedTableColumn : FixedStringTableCo...
method FixedStringDecodedTableColumn (line 27) | public FixedStringDecodedTableColumn(Memory<byte> buffer, int rowSize,...
method GetValue (line 32) | protected override string GetValue(Encoding encoding, ReadOnlySpan<byt...
FILE: src/Octonica.ClickHouseClient/Types/FixedStringTableColumn.cs
class FixedStringTableColumn (line 24) | internal sealed class FixedStringTableColumn : FixedStringTableColumnBas...
method FixedStringTableColumn (line 28) | public FixedStringTableColumn(Memory<byte> buffer, int rowSize, Encodi...
method GetValue (line 33) | [return: NotNull]
FILE: src/Octonica.ClickHouseClient/Types/FixedStringTableColumnBase.cs
class FixedStringTableColumnBase (line 24) | internal abstract class FixedStringTableColumnBase<TOut> : IClickHouseTa...
method FixedStringTableColumnBase (line 34) | protected FixedStringTableColumnBase(Memory<byte> buffer, int rowSize,...
method IsNull (line 42) | public bool IsNull(int index)
method GetValue (line 47) | [return: NotNull]
method GetValue (line 53) | [return: NotNull]
method GetValue (line 56) | object IClickHouseTableColumn.GetValue(int index)
method TryReinterpret (line 61) | public IClickHouseTableColumn<T>? TryReinterpret<T>()
method TryDipatch (line 73) | bool IClickHouseTableColumn.TryDipatch<T>(IClickHouseTableColumnDispat...
method CopyTo (line 79) | public int CopyTo(int index, Span<byte> buffer, int dataOffset)
FILE: src/Octonica.ClickHouseClient/Types/FixedStringTypeInfo.cs
class FixedStringTypeInfo (line 31) | internal sealed class FixedStringTypeInfo : IClickHouseColumnTypeInfo
method FixedStringTypeInfo (line 43) | public FixedStringTypeInfo()
method FixedStringTypeInfo (line 48) | private FixedStringTypeInfo(int length)
method CreateColumnReader (line 54) | public IClickHouseColumnReader CreateColumnReader(int rowCount)
method CreateSkippingColumnReader (line 62) | public IClickHouseColumnReaderBase CreateSkippingColumnReader(int rowC...
method CreateColumnWriter (line 70) | public IClickHouseColumnWriter CreateColumnWriter<T>(string columnName...
method CreateParameterWriter (line 92) | public IClickHouseParameterWriter<T> CreateParameterWriter<T>()
method GetDetailedTypeInfo (line 120) | public IClickHouseColumnTypeInfo GetDetailedTypeInfo(List<ReadOnlyMemo...
method GetFieldType (line 134) | public Type GetFieldType()
method GetDbType (line 139) | public ClickHouseDbType GetDbType()
method GetGenericArgument (line 144) | public IClickHouseTypeInfo GetGenericArgument(int index)
method GetTypeArgument (line 149) | public object GetTypeArgument(int index)
class FixedStringReader (line 160) | private sealed class FixedStringReader : IClickHouseColumnReader
method FixedStringReader (line 169) | public FixedStringReader(int rowCount, int rowSize)
method ReadNext (line 177) | public SequenceSize ReadNext(ReadOnlySequence<byte> sequence)
method EndRead (line 195) | public IClickHouseTableColumn EndRead(ClickHouseColumnSettings? sett...
class FixedStringBytesColumnWriter (line 201) | private sealed class FixedStringBytesColumnWriter : FixedStringColumnW...
method FixedStringBytesColumnWriter (line 207) | public FixedStringBytesColumnWriter(string columnName, string column...
method FixedStringBytesColumnWriter (line 212) | public FixedStringBytesColumnWriter(string columnName, string column...
method FixedStringBytesColumnWriter (line 217) | public FixedStringBytesColumnWriter(string columnName, string column...
method GetBytes (line 223) | protected override int GetBytes(int position, Span<byte> buffer)
class FixedStringStringColumnWriter (line 234) | private sealed class FixedStringStringColumnWriter : FixedStringColumn...
method FixedStringStringColumnWriter (line 241) | public FixedStringStringColumnWriter(string columnName, string colum...
method FixedStringStringColumnWriter (line 246) | public FixedStringStringColumnWriter(string columnName, string colum...
method FixedStringStringColumnWriter (line 251) | public FixedStringStringColumnWriter(string columnName, string colum...
method GetBytes (line 258) | protected override int GetBytes(int position, Span<byte> buffer)
class FixedStringColumnWriterBase (line 275) | private abstract class FixedStringColumnWriterBase : IClickHouseColumn...
method FixedStringColumnWriterBase (line 287) | public FixedStringColumnWriterBase(string columnName, string columnT...
method WriteNext (line 294) | public SequenceSize WriteNext(Span<byte> writeTo)
method GetBytes (line 309) | protected abstract int GetBytes(int position, Span<byte> buffer);
class FixedStringParameterWriter (line 312) | private class FixedStringParameterWriter : IClickHouseParameterWriter<...
method FixedStringParameterWriter (line 316) | public FixedStringParameterWriter(FixedStringTypeInfo type)
method TryCreateParameterValueWriter (line 321) | public bool TryCreateParameterValueWriter(ReadOnlyMemory<char> value...
method Interpolate (line 333) | public StringBuilder Interpolate(StringBuilder queryBuilder, ReadOnl...
method Interpolate (line 339) | public StringBuilder Interpolate(StringBuilder queryBuilder, IClickH...
method ValidateLength (line 344) | private void ValidateLength(ReadOnlyMemory<char> value)
method FixedStringParameterWriter (line 359) | public FixedStringParameterWriter(FixedStringTypeInfo type, Func<T, ...
method TryCreateParameterValueWriter (line 365) | public bool TryCreateParameterValueWriter(T value, bool isNested, [N...
method Interpolate (line 370) | public StringBuilder Interpolate(StringBuilder queryBuilder, T value)
class FixedStringParameterWriter (line 355) | private sealed class FixedStringParameterWriter<T> : FixedStringParame...
method FixedStringParameterWriter (line 316) | public FixedStringParameterWriter(FixedStringTypeInfo type)
method TryCreateParameterValueWriter (line 321) | public bool TryCreateParameterValueWriter(ReadOnlyMemory<char> value...
method Interpolate (line 333) | public StringBuilder Interpolate(StringBuilder queryBuilder, ReadOnl...
method Interpolate (line 339) | public StringBuilder Interpolate(StringBuilder queryBuilder, IClickH...
method ValidateLength (line 344) | private void ValidateLength(ReadOnlyMemory<char> value)
method FixedStringParameterWriter (line 359) | public FixedStringParameterWriter(FixedStringTypeInfo type, Func<T, ...
method TryCreateParameterValueWriter (line 365) | public bool TryCreateParameterValueWriter(T value, bool isNested, [N...
method Interpolate (line 370) | public StringBuilder Interpolate(StringBuilder queryBuilder, T value)
class FixedStringHexParameterWriter (line 376) | private class FixedStringHexParameterWriter : IClickHouseParameterWrit...
method FixedStringHexParameterWriter (line 380) | public FixedStringHexParameterWriter(FixedStringTypeInfo type)
method TryCreateParameterValueWriter (line 385) | public bool TryCreateParameterValueWriter(ReadOnlyMemory<byte> value...
method Interpolate (line 392) | public StringBuilder Interpolate(StringBuilder queryBuilder, ReadOnl...
method Interpolate (line 398) | public StringBuilder Interpolate(StringBuilder queryBuilder, IClickH...
method ValidateLength (line 403) | private void ValidateLength(ReadOnlyMemory<byte> value)
method FixedStringHexParameterWriter (line 416) | public FixedStringHexParameterWriter(FixedStringTypeInfo type, Func<...
method TryCreateParameterValueWriter (line 422) | public bool TryCreateParameterValueWriter(T value, bool isNested, [N...
method Interpolate (line 427) | public StringBuilder Interpolate(StringBuilder queryBuilder, T value)
class FixedStringHexParameterWriter (line 412) | private sealed class FixedStringHexParameterWriter<T> : FixedStringHex...
method FixedStringHexParameterWriter (line 380) | public FixedStringHexParameterWriter(FixedStringTypeInfo type)
method TryCreateParameterValueWriter (line 385) | public bool TryCreateParameterValueWriter(ReadOnlyMemory<byte> value...
method Interpolate (line 392) | public StringBuilder Interpolate(StringBuilder queryBuilder, ReadOnl...
method Interpolate (line 398) | public StringBuilder Interpolate(StringBuilder queryBuilder, IClickH...
method ValidateLength (line 403) | private void ValidateLength(ReadOnlyMemory<byte> value)
method FixedStringHexParameterWriter (line 416) | public FixedStringHexParameterWriter(FixedStringTypeInfo type, Func<...
method TryCreateParameterValueWriter (line 422) | public bool TryCreateParameterValueWriter(T value, bool isNested, [N...
method Interpolate (line 427) | public StringBuilder Interpolate(StringBuilder queryBuilder, T value)
FILE: src/Octonica.ClickHouseClient/Types/Float32TableColumn.cs
class Float32TableColumn (line 22) | internal sealed class Float32TableColumn : StructureTableColumn<float>
method Float32TableColumn (line 24) | public Float32TableColumn(ReadOnlyMemory<float> buffer)
method TryReinterpret (line 29) | public override IClickHouseTableColumn<T>? TryReinterpret<T>()
FILE: src/Octonica.ClickHouseClient/Types/Float32TypeInfo.cs
class Float32TypeInfo (line 26) | internal sealed class Float32TypeInfo : SimpleTypeInfo
method Float32TypeInfo (line 28) | public Float32TypeInfo()
method CreateColumnReader (line 33) | public override IClickHouseColumnReader CreateColumnReader(int rowCount)
method CreateSkippingColumnReader (line 38) | public override IClickHouseColumnReaderBase CreateSkippingColumnReader...
method CreateColumnWriter (line 43) | public override IClickHouseColumnWriter CreateColumnWriter<T>(string c...
method CreateParameterWriter (line 51) | public override IClickHouseParameterWriter<T> CreateParameterWriter<T>()
method GetFieldType (line 66) | public override Type GetFieldType()
method GetDbType (line 71) | public override ClickHouseDbType GetDbType()
class Float32Reader (line 76) | private sealed class Float32Reader : StructureReaderBase<float>
method Float32Reader (line 80) | public Float32Reader(int rowCount)
method ReadElement (line 85) | protected override float ReadElement(ReadOnlySpan<byte> source)
method EndRead (line 90) | protected override IClickHouseTableColumn<float> EndRead(ClickHouseC...
class Float32Writer (line 96) | private sealed class Float32Writer : StructureWriterBase<float>
method Float32Writer (line 100) | public Float32Writer(string columnName, string columnType, IReadOnly...
method WriteElement (line 105) | protected override void WriteElement(Span<byte> writeTo, in float va...
FILE: src/Octonica.ClickHouseClient/Types/Float64TypeInfo.cs
class Float64TypeInfo (line 27) | internal sealed class Float64TypeInfo : SimpleTypeInfo
method Float64TypeInfo (line 29) | public Float64TypeInfo()
method CreateColumnReader (line 34) | public override IClickHouseColumnReader CreateColumnReader(int rowCount)
method CreateSkippingColumnReader (line 39) | public override IClickHouseColumnReaderBase CreateSkippingColumnReader...
method CreateColumnWriter (line 44) | public override IClickHouseColumnWriter CreateColumnWriter<T>(string c...
method CreateParameterWriter (line 57) | public override IClickHouseParameterWriter<T> CreateParameterWriter<T>()
method GetFieldType (line 73) | public override Type GetFieldType()
method GetDbType (line 78) | public override ClickHouseDbType GetDbType()
class Float64Reader (line 83) | private sealed class Float64Reader : StructureReaderBase<double>
method Float64Reader (line 87) | public Float64Reader(int rowCount)
method ReadElement (line 92) | protected override double ReadElement(ReadOnlySpan<byte> source)
class Float64Writer (line 98) | private sealed class Float64Writer : StructureWriterBase<double>
method Float64Writer (line 102) | public Float64Writer(string columnName, string columnType, IReadOnly...
method WriteElement (line 107) | protected override void WriteElement(Span<byte> writeTo, in double v...
FILE: src/Octonica.ClickHouseClient/Types/HexStringLiteralValueWriter.cs
class HexStringLiteralValueWriter (line 24) | internal sealed class HexStringLiteralValueWriter : IClickHouseParameter...
method HexStringLiteralValueWriter (line 33) | public HexStringLiteralValueWriter(ReadOnlyMemory<byte> value, bool in...
method Write (line 44) | public int Write(Memory<byte> buffer)
FILE: src/Octonica.ClickHouseClient/Types/HexStringLiteralWriterCastMode.cs
type HexStringLiteralWriterCastMode (line 20) | internal enum HexStringLiteralWriterCastMode
FILE: src/Octonica.ClickHouseClient/Types/HexStringParameterWriter.cs
class HexStringParameterWriter (line 30) | internal sealed class HexStringParameterWriter : IClickHouseParameterWri...
method HexStringParameterWriter (line 36) | public HexStringParameterWriter(IClickHouseColumnTypeInfo typeInfo)
method TryCreateParameterValueWriter (line 41) | public bool TryCreateParameterValueWriter(ReadOnlyMemory<byte> value, ...
method Interpolate (line 47) | public StringBuilder Interpolate(StringBuilder queryBuilder, ReadOnlyM...
method Interpolate (line 52) | public static StringBuilder Interpolate(StringBuilder queryBuilder, Re...
method Interpolate (line 64) | public StringBuilder Interpolate(StringBuilder queryBuilder, IClickHou...
method Create (line 69) | public static HexStringParameterWriter<T> Create<T>(IClickHouseColumnT...
method Create (line 78) | public static HexStringParameterWriter<TIn> Create<TIn, TOut>(IClickHo...
method Convert (line 87) | private static ReadOnlyMemory<byte> Convert<T>(T value)
method HexStringParameterWriter (line 104) | public HexStringParameterWriter(IClickHouseColumnTypeInfo typeInfo, Fu...
method HexStringParameterWriter (line 109) | public HexStringParameterWriter(IClickHouseColumnTypeInfo typeInfo, He...
method TryCreateParameterValueWriter (line 117) | public bool TryCreateParameterValueWriter(T value, bool isNested, [Not...
method Interpolate (line 124) | public StringBuilder Interpolate(StringBuilder queryBuilder, T value)
method Interpolate (line 167) | public StringBuilder Interpolate(StringBuilder queryBuilder, IClickHou...
class HexStringParameterWriter (line 97) | internal sealed class HexStringParameterWriter<T> : IClickHouseParameter...
method HexStringParameterWriter (line 36) | public HexStringParameterWriter(IClickHouseColumnTypeInfo typeInfo)
method TryCreateParameterValueWriter (line 41) | public bool TryCreateParameterValueWriter(ReadOnlyMemory<byte> value, ...
method Interpolate (line 47) | public StringBuilder Interpolate(StringBuilder queryBuilder, ReadOnlyM...
method Interpolate (line 52) | public static StringBuilder Interpolate(StringBuilder queryBuilder, Re...
method Interpolate (line 64) | public StringBuilder Interpolate(StringBuilder queryBuilder, IClickHou...
method Create (line 69) | public static HexStringParameterWriter<T> Create<T>(IClickHouseColumnT...
method Create (line 78) | public static HexStringParameterWriter<TIn> Create<TIn, TOut>(IClickHo...
method Convert (line 87) | private static ReadOnlyMemory<byte> Convert<T>(T value)
method HexStringParameterWriter (line 104) | public HexStringParameterWriter(IClickHouseColumnTypeInfo typeInfo, Fu...
method HexStringParameterWriter (line 109) | public HexStringParameterWriter(IClickHouseColumnTypeInfo typeInfo, He...
method TryCreateParameterValueWriter (line 117) | public bool TryCreateParameterValueWriter(T value, bool isNested, [Not...
method Interpolate (line 124) | public StringBuilder Interpolate(StringBuilder queryBuilder, T value)
method Interpolate (line 167) | public StringBuilder Interpolate(StringBuilder queryBuilder, IClickHou...
FILE: src/Octonica.ClickHouseClient/Types/IClickHouseColumnReinterpreter.cs
type IClickHouseColumnReinterpreter (line 22) | internal interface IClickHouseColumnReinterpreter
method TryReinterpret (line 28) | IClickHouseTableColumn? TryReinterpret(IClickHouseTableColumn column);
FILE: src/Octonica.ClickHouseClient/Types/IClickHouseColumnTypeDescriptor.cs
type IClickHouseColumnTypeDescriptor (line 25) | public interface IClickHouseColumnTypeDescriptor
FILE: src/Octonica.ClickHouseClient/Types/IClickHouseColumnTypeInfo.cs
type IClickHouseColumnTypeInfo (line 30) | public interface IClickHouseColumnTypeInfo : IClickHouseTypeInfo
method CreateColumnReader (line 37) | IClickHouseColumnReader CreateColumnReader(int rowCount);
method CreateColumnReader (line 49) | IClickHouseColumnReader CreateColumnReader(int rowCount, ClickHouseCol...
method CreateSkippingColumnReader (line 70) | IClickHouseColumnReaderBase CreateSkippingColumnReader(int rowCount);
method CreateSkippingColumnReader (line 82) | IClickHouseColumnReaderBase CreateSkippingColumnReader(int rowCount, C...
method CreateColumnWriter (line 106) | IClickHouseColumnWriter CreateColumnWriter<T>(string columnName, IRead...
method GetDetailedTypeInfo (line 114) | IClickHouseColumnTypeInfo GetDetailedTypeInfo(List<ReadOnlyMemory<char...
method CreateParameterWriter (line 121) | IClickHouseParameterWriter<T> CreateParameterWriter<T>();
FILE: src/Octonica.ClickHouseClient/Types/IClickHouseConfigurableTypeInfo.cs
type IClickHouseConfigurableTypeInfo (line 24) | public interface IClickHouseConfigurableTypeInfo : IClickHouseColumnType...
method Configure (line 31) | IClickHouseColumnTypeInfo Configure(ClickHouseServerInfo serverInfo);
FILE: src/Octonica.ClickHouseClient/Types/IClickHouseEnumConverter.cs
type IClickHouseEnumConverter (line 26) | public interface IClickHouseEnumConverter
method Dispatch (line 35) | public T Dispatch<T>(IClickHouseEnumConverterDispatcher<T> dispatcher);
method TryMap (line 53) | bool TryMap(int value, string stringValue, [NotNullWhen(true)] out TEn...
type IClickHouseEnumConverter (line 43) | public interface IClickHouseEnumConverter<TEnum> : IClickHouseEnumConverter
method Dispatch (line 35) | public T Dispatch<T>(IClickHouseEnumConverterDispatcher<T> dispatcher);
method TryMap (line 53) | bool TryMap(int value, string stringValue, [NotNullWhen(true)] out TEn...
type IClickHouseEnumConverterDispatcher (line 60) | public interface IClickHouseEnumConverterDispatcher<out T>
method Dispatch (line 70) | public T Dispatch<TEnum>(IClickHouseEnumConverter<TEnum> enumConverter)
FILE: src/Octonica.ClickHouseClient/Types/IClickHouseReinterpretedTableColumn.cs
type IClickHouseReinterpretedTableColumn (line 22) | internal interface IClickHouseReinterpretedTableColumn<out T>: IClickHou...
method Chain (line 24) | IClickHouseReinterpretedTableColumn<TResult> Chain<TResult>(Func<T, TR...
FILE: src/Octonica.ClickHouseClient/Types/IClickHouseTypeInfo.cs
type IClickHouseTypeInfo (line 25) | public interface IClickHouseTypeInfo
method GetFieldType (line 52) | Type GetFieldType();
method GetDbType (line 57) | ClickHouseDbType GetDbType();
method GetGenericArgument (line 65) | IClickHouseTypeInfo GetGenericArgument(int index);
method GetTypeArgument (line 72) | object GetTypeArgument(int index)
FILE: src/Octonica.ClickHouseClient/Types/IClickHouseTypeInfoProvider.cs
type IClickHouseTypeInfoProvider (line 25) | public interface IClickHouseTypeInfoProvider
method GetTypeInfo (line 32) | IClickHouseColumnTypeInfo GetTypeInfo(string typeName);
method GetTypeInfo (line 35) | IClickHouseColumnTypeInfo GetTypeInfo(ReadOnlyMemory<char> typeName);
method GetTypeInfo (line 42) | IClickHouseColumnTypeInfo GetTypeInfo(IClickHouseColumnTypeDescriptor ...
method Configure (line 49) | IClickHouseTypeInfoProvider Configure(ClickHouseServerInfo serverInfo);
FILE: src/Octonica.ClickHouseClient/Types/Int128TypeInfo.cs
class Int128TypeInfo (line 20) | internal sealed class Int128TypeInfo : BigIntegerTypeInfoBase
method Int128TypeInfo (line 22) | public Int128TypeInfo()
method GetDbType (line 27) | public override ClickHouseDbType GetDbType()
FILE: src/Octonica.ClickHouseClient/Types/Int16TableColumn.cs
class Int16TableColumn (line 22) | internal sealed class Int16TableColumn : StructureTableColumn<short>
method Int16TableColumn (line 24) | public Int16TableColumn(ReadOnlyMemory<short> buffer)
method TryReinterpret (line 29) | public override IClickHouseTableColumn<T>? TryReinterpret<T>()
FILE: src/Octonica.ClickHouseClient/Types/Int16TypeInfo.cs
class Int16TypeInfo (line 27) | internal sealed class Int16TypeInfo : SimpleTypeInfo
method Int16TypeInfo (line 29) | public Int16TypeInfo()
method CreateColumnReader (line 34) | public override IClickHouseColumnReader CreateColumnReader(int rowCount)
method CreateSkippingColumnReader (line 39) | public override IClickHouseColumnReaderBase CreateSkippingColumnReader...
method CreateColumnWriter (line 44) | public override IClickHouseColumnWriter CreateColumnWriter<T>(string c...
method CreateParameterWriter (line 60) | public override IClickHouseParameterWriter<T> CreateParameterWriter<T>()
method GetFieldType (line 77) | public override Type GetFieldType()
method GetDbType (line 82) | public override ClickHouseDbType GetDbType()
class Int16Reader (line 87) | internal sealed class Int16Reader : StructureReaderBase<short>
method Int16Reader (line 91) | public Int16Reader(int rowCount)
method ReadElement (line 96) | protected override short ReadElement(ReadOnlySpan<byte> source)
method EndRead (line 101) | protected override IClickHouseTableColumn<short> EndRead(ClickHouseC...
class Int16Writer (line 107) | internal sealed class Int16Writer : StructureWriterBase<short>
method Int16Writer (line 111) | public Int16Writer(string columnName, string columnType, IReadOnlyLi...
method WriteElement (line 116) | protected override void WriteElement(Span<byte> writeTo, in short va...
FILE: src/Octonica.ClickHouseClient/Types/Int256TypeInfo.cs
class Int256TypeInfo (line 20) | internal sealed class Int256TypeInfo : BigIntegerTypeInfoBase
method Int256TypeInfo (line 22) | public Int256TypeInfo()
method GetDbType (line 27) | public override ClickHouseDbType GetDbType()
FILE: src/Octonica.ClickHouseClient/Types/Int32TableColumn.cs
class Int32TableColumn (line 22) | internal sealed class Int32TableColumn : StructureTableColumn<int>
method Int32TableColumn (line 24) | public Int32TableColumn(ReadOnlyMemory<int> buffer)
method TryReinterpret (line 29) | public override IClickHouseTableColumn<T>? TryReinterpret<T>()
FILE: src/Octonica.ClickHouseClient/Types/Int32TypeInfo.cs
class Int32TypeInfo (line 27) | internal sealed class Int32TypeInfo : SimpleTypeInfo
method Int32TypeInfo (line 29) | public Int32TypeInfo()
method CreateColumnReader (line 34) | public override IClickHouseColumnReader CreateColumnReader(int rowCount)
method CreateSkippingColumnReader (line 39) | public override IClickHouseColumnReaderBase CreateSkippingColumnReader...
method CreateColumnWriter (line 44) | public override IClickHouseColumnWriter CreateColumnWriter<T>(string c...
method CreateParameterWriter (line 64) | public override IClickHouseParameterWriter<T> CreateParameterWriter<T>()
method GetFieldType (line 83) | public override Type GetFieldType()
method GetDbType (line 88) | public override ClickHouseDbType GetDbType()
class Int32Reader (line 93) | private sealed class Int32Reader : StructureReaderBase<int>
method Int32Reader (line 97) | public Int32Reader(int rowCount)
method ReadElement (line 102) | protected override int ReadElement(ReadOnlySpan<byte> source)
method EndRead (line 107) | protected override IClickHouseTableColumn<int> EndRead(ClickHouseCol...
class Int32Writer (line 113) | private sealed class Int32Writer : StructureWriterBase<int>
method Int32Writer (line 117) | public Int32Writer(string columnName, string columnType, IReadOnlyLi...
method WriteElement (line 122) | protected override void WriteElement(Span<byte> writeTo, in int value)
FILE: src/Octonica.ClickHouseClient/Types/Int64TypeInfo.cs
class Int64TypeInfo (line 29) | internal sealed class Int64TypeInfo : SimpleTypeInfo
method Int64TypeInfo (line 31) | public Int64TypeInfo()
method CreateColumnReader (line 36) | public override IClickHouseColumnReader CreateColumnReader(int rowCount)
method CreateSkippingColumnReader (line 41) | public override IClickHouseColumnReaderBase CreateSkippingColumnReader...
method CreateColumnWriter (line 46) | public override IClickHouseColumnWriter CreateColumnWriter<T>(string c...
method CreateParameterWriter (line 70) | public override IClickHouseParameterWriter<T> CreateParameterWriter<T>()
method GetFieldType (line 90) | public override Type GetFieldType()
method GetDbType (line 95) | public override ClickHouseDbType GetDbType()
class Int64Reader (line 100) | private sealed class Int64Reader : StructureReaderBase<long>
method Int64Reader (line 104) | public Int64Reader(int rowCount)
method ReadElement (line 109) | protected override long ReadElement(ReadOnlySpan<byte> source)
class Int64Writer (line 115) | private sealed class Int64Writer : StructureWriterBase<long>
method Int64Writer (line 119) | public Int64Writer(string columnName, string columnType, IReadOnlyLi...
method WriteElement (line 124) | protected override void WriteElement(Span<byte> writeTo, in long value)
FILE: src/Octonica.ClickHouseClient/Types/Int8TableColumn.cs
class Int8TableColumn (line 22) | internal sealed class Int8TableColumn : StructureTableColumn<sbyte>
method Int8TableColumn (line 24) | public Int8TableColumn(ReadOnlyMemory<sbyte> buffer)
method TryReinterpret (line 29) | public override IClickHouseTableColumn<T>? TryReinterpret<T>()
FILE: src/Octonica.ClickHouseClient/Types/Int8TypeInfo.cs
class Int8TypeInfo (line 25) | internal sealed class Int8TypeInfo : SimpleTypeInfo
method Int8TypeInfo (line 27) | public Int8TypeInfo()
method CreateColumnReader (line 32) | public override IClickHouseColumnReader CreateColumnReader(int rowCount)
method CreateSkippingColumnReader (line 37) | public override IClickHouseColumnReaderBase CreateSkippingColumnReader...
method CreateColumnWriter (line 42) | public override IClickHouseColumnWriter CreateColumnWriter<T>(string c...
method CreateParameterWriter (line 50) | public override IClickHouseParameterWriter<T> CreateParameterWriter<T>()
method GetFieldType (line 62) | public override Type GetFieldType()
method GetDbType (line 67) | public override ClickHouseDbType GetDbType()
class Int8Reader (line 72) | internal sealed class Int8Reader : StructureReaderBase<sbyte>
method Int8Reader (line 76) | public Int8Reader(int rowCount)
method ReadElement (line 81) | protected override sbyte ReadElement(ReadOnlySpan<byte> source)
method EndRead (line 86) | protected override IClickHouseTableColumn<sbyte> EndRead(ClickHouseC...
class Int8Writer (line 92) | internal sealed class Int8Writer : IClickHouseColumnWriter
method Int8Writer (line 102) | public Int8Writer(string columnName, string columnType, IReadOnlyLis...
method WriteNext (line 109) | public SequenceSize WriteNext(Span<byte> writeTo)
FILE: src/Octonica.ClickHouseClient/Types/IntermediateClickHouseTypeInfo.cs
type IntermediateClickHouseTypeInfo (line 20) | internal readonly struct IntermediateClickHouseTypeInfo
method IntermediateClickHouseTypeInfo (line 27) | public IntermediateClickHouseTypeInfo(ClickHouseDbType dbType, string ...
FILE: src/Octonica.ClickHouseClient/Types/IpColumnReaderBase.cs
class IpColumnReaderBase (line 26) | internal abstract class IpColumnReaderBase : IClickHouseColumnReader
method IpColumnReaderBase (line 35) | protected IpColumnReaderBase(int rowCount, int elementSize)
method ReadNext (line 42) | public SequenceSize ReadNext(ReadOnlySequence<byte> sequence)
method EndRead (line 58) | public IClickHouseTableColumn EndRead(ClickHouseColumnSettings? settings)
method EndRead (line 63) | protected abstract IClickHouseTableColumn<IPAddress> EndRead(ReadOnlyM...
FILE: src/Octonica.ClickHouseClient/Types/IpV4TableColumn.cs
class IpV4TableColumn (line 24) | internal sealed class IpV4TableColumn: IClickHouseTableColumn<IPAddress>
method IpV4TableColumn (line 32) | public IpV4TableColumn(ReadOnlyMemory<byte> buffer)
method IsNull (line 37) | public bool IsNull(int index)
method GetValue (line 42) | public IPAddress GetValue(int index)
method GetValue (line 52) | object IClickHouseTableColumn.GetValue(int index)
method TryReinterpret (line 57) | public IClickHouseTableColumn<T>? TryReinterpret<T>()
method TryDipatch (line 88) | bool IClickHouseTableColumn.TryDipatch<T>(IClickHouseTableColumnDispat...
class RawIpV4TableColumn (line 94) | private sealed class RawIpV4TableColumn<TStruct> : IClickHouseTableCol...
method RawIpV4TableColumn (line 104) | public RawIpV4TableColumn(ReadOnlyMemory<byte> buffer, Func<ReadOnly...
method IsNull (line 110) | public bool IsNull(int index)
method GetValue (line 115) | public TStruct GetValue(int index)
method GetValue (line 120) | object IClickHouseTableColumn.GetValue(int index)
method TryReinterpret (line 125) | public IClickHouseTableColumn<T>? TryReinterpret<T>()
method TryDipatch (line 130) | bool IClickHouseTableColumn.TryDipatch<T>(IClickHouseTableColumnDisp...
FILE: src/Octonica.ClickHouseClient/Types/IpV4TypeInfo.cs
class IpV4TypeInfo (line 30) | internal sealed class IpV4TypeInfo : SimpleTypeInfo
method IpV4TypeInfo (line 32) | public IpV4TypeInfo()
method CreateColumnReader (line 37) | public override IClickHouseColumnReader CreateColumnReader(int rowCount)
method CreateSkippingColumnReader (line 42) | public override IClickHouseColumnReaderBase CreateSkippingColumnReader...
method CreateColumnWriter (line 47) | public override IClickHouseColumnWriter CreateColumnWriter<T>(string c...
method CreateParameterWriter (line 66) | public override IClickHouseParameterWriter<T> CreateParameterWriter<T>()
method GetFieldType (line 88) | public override Type GetFieldType()
method GetDbType (line 93) | public override ClickHouseDbType GetDbType()
method IpAddressStringToUInt32 (line 98) | private static uint IpAddressStringToUInt32(string? address)
method IpAddressToUInt32 (line 109) | private static uint IpAddressToUInt32(IPAddress? address)
class IpV4Reader (line 127) | private sealed class IpV4Reader : IpColumnReaderBase
method IpV4Reader (line 129) | public IpV4Reader(int rowCount)
method EndRead (line 134) | protected override IClickHouseTableColumn<IPAddress> EndRead(ReadOnl...
class IpV4Writer (line 140) | private sealed class IpV4Writer : StructureWriterBase<uint>
method IpV4Writer (line 144) | public IpV4Writer(string columnName, string columnType, IReadOnlyLis...
method WriteElement (line 149) | protected override void WriteElement(Span<byte> writeTo, in uint value)
FILE: src/Octonica.ClickHouseClient/Types/IpV6TableColumn.cs
class IpV6TableColumn (line 23) | internal sealed class IpV6TableColumn : IClickHouseTableColumn<IPAddress>
method IpV6TableColumn (line 31) | public IpV6TableColumn(ReadOnlyMemory<byte> buffer)
method IsNull (line 36) | public bool IsNull(int index)
method GetValue (line 41) | public IPAddress GetValue(int index)
method GetValue (line 46) | object IClickHouseTableColumn.GetValue(int index)
method TryReinterpret (line 51) | public IClickHouseTableColumn<T>? TryReinterpret<T>()
method TryDipatch (line 59) | bool IClickHouseTableColumn.TryDipatch<T>(IClickHouseTableColumnDispat...
FILE: src/Octonica.ClickHouseClient/Types/IpV6TypeInfo.cs
class IpV6TypeInfo (line 31) | internal sealed class IpV6TypeInfo: SimpleTypeInfo
method IpV6TypeInfo (line 35) | public IpV6TypeInfo()
method CreateColumnReader (line 40) | public override IClickHouseColumnReader CreateColumnReader(int rowCount)
method CreateSkippingColumnReader (line 45) | public override IClickHouseColumnReaderBase CreateSkippingColumnReader...
method CreateColumnWriter (line 50) | public override IClickHouseColumnWriter CreateColumnWriter<T>(string c...
method CreateParameterWriter (line 64) | public override IClickHouseParameterWriter<T> CreateParameterWriter<T>()
method GetFieldType (line 82) | public override Type GetFieldType()
method GetDbType (line 87) | public override ClickHouseDbType GetDbType()
method ParseIpAddress (line 92) | [return: NotNullIfNotNull("address")]
method GetBytes (line 104) | private static byte[] GetBytes(IPAddress ipAddress)
method WriteBytes (line 111) | [MethodImpl(MethodImplOptions.AggressiveInlining)]
class IpV6Reader (line 124) | private sealed class IpV6Reader : IpColumnReaderBase
method IpV6Reader (line 126) | public IpV6Reader(int rowCount)
method EndRead (line 131) | protected override IClickHouseTableColumn<IPAddress> EndRead(ReadOnl...
class IpV6Writer (line 137) | private sealed class IpV6Writer : IClickHouseColumnWriter
method IpV6Writer (line 147) | public IpV6Writer(string columnName, string columnType, IReadOnlyLis...
method WriteNext (line 154) | public SequenceSize WriteNext(Span<byte> writeTo)
FILE: src/Octonica.ClickHouseClient/Types/KeyValuePairTableColumn.cs
class KeyValuePairTableColumn (line 23) | internal sealed class KeyValuePairTableColumn<TKey, TValue> : TupleTable...
method KeyValuePairTableColumn (line 30) | public KeyValuePairTableColumn(int rowCount, IClickHouseTableColumn<TK...
method GetTupleValue (line 37) | protected override object GetTupleValue(int index)
method GetValue (line 42) | public new KeyValuePair<TKey, TValue> GetValue(int index)
method GetColumns (line 49) | public override IEnumerable<IClickHouseTableColumn> GetColumns()
method Dispatch (line 55) | protected override T Dispatch<T>(IClickHouseTableColumnDispatcher<T> d...
class Reinterpreter (line 60) | internal class Reinterpreter : ReinterpreterBase
method TryReinterpret (line 62) | public override TupleTableColumnBase? TryReinterpret(int rowCount, I...
FILE: src/Octonica.ClickHouseClient/Types/LowCardinalityTableColumn.cs
class LowCardinalityTableColumn (line 25) | internal sealed class LowCardinalityTableColumn : IClickHouseTableColumn
method LowCardinalityTableColumn (line 34) | public LowCardinalityTableColumn(ReadOnlyMemory<byte> keys, int keySiz...
method IsNull (line 43) | public bool IsNull(int index)
method GetValue (line 52) | public object GetValue(int index)
method TryReinterpret (line 61) | public IClickHouseTableColumn<T>? TryReinterpret<T>()
method TryReinterpretAsArray (line 70) | IClickHouseArrayTableColumn<T>? IClickHouseTableColumn.TryReinterpretA...
method TryDipatch (line 79) | bool IClickHouseTableColumn.TryDipatch<T>(IClickHouseTableColumnDispat...
method GetValueIndex (line 85) | private int GetValueIndex(int index)
method LowCardinalityTableColumn (line 109) | public LowCardinalityTableColumn(ReadOnlyMemory<byte> keys, int keySiz...
method IsNull (line 118) | public bool IsNull(int index)
method GetValue (line 127) | public TValue GetValue(int index)
method GetValue (line 142) | object IClickHouseTableColumn.GetValue(int index)
method TryReinterpret (line 151) | public IClickHouseTableColumn<T>? TryReinterpret<T>()
method TryReinterpretAsArray (line 160) | IClickHouseArrayTableColumn<T>? IClickHouseTableColumn.TryReinterpretA...
method TryDipatch (line 169) | bool IClickHouseTableColumn.TryDipatch<T>(IClickHouseTableColumnDispat...
method GetValueIndex (line 175) | private int GetValueIndex(int index)
class LowCardinalityTableColumn (line 98) | internal sealed class LowCardinalityTableColumn<TValue> : IClickHouseTab...
method LowCardinalityTableColumn (line 34) | public LowCardinalityTableColumn(ReadOnlyMemory<byte> keys, int keySiz...
method IsNull (line 43) | public bool IsNull(int index)
method GetValue (line 52) | public object GetValue(int index)
method TryReinterpret (line 61) | public IClickHouseTableColumn<T>? TryReinterpret<T>()
method TryReinterpretAsArray (line 70) | IClickHouseArrayTableColumn<T>? IClickHouseTableColumn.TryReinterpretA...
method TryDipatch (line 79) | bool IClickHouseTableColumn.TryDipatch<T>(IClickHouseTableColumnDispat...
method GetValueIndex (line 85) | private int GetValueIndex(int index)
method LowCardinalityTableColumn (line 109) | public LowCardinalityTableColumn(ReadOnlyMemory<byte> keys, int keySiz...
method IsNull (line 118) | public bool IsNull(int index)
method GetValue (line 127) | public TValue GetValue(int index)
method GetValue (line 142) | object IClickHouseTableColumn.GetValue(int index)
method TryReinterpret (line 151) | public IClickHouseTableColumn<T>? TryReinterpret<T>()
method TryReinterpretAsArray (line 160) | IClickHouseArrayTableColumn<T>? IClickHouseTableColumn.TryReinterpretA...
method TryDipatch (line 169) | bool IClickHouseTableColumn.TryDipatch<T>(IClickHouseTableColumnDispat...
method GetValueIndex (line 175) | private int GetValueIndex(int index)
class LowCardinalityArrayTableColumn (line 188) | internal sealed class LowCardinalityArrayTableColumn<TElement> : IClickH...
method LowCardinalityArrayTableColumn (line 198) | public LowCardinalityArrayTableColumn(IClickHouseTableColumn reinterpr...
method CopyTo (line 208) | public int CopyTo(int index, Span<TElement> buffer, int dataOffset)
method GetValue (line 217) | public object GetValue(int index)
method IsNull (line 226) | public bool IsNull(int index)
method TryReinterpret (line 235) | public IClickHouseTableColumn<T>? TryReinterpret<T>()
method TryReinterpretAsArray (line 240) | IClickHouseArrayTableColumn<T>? IClickHouseTableColumn.TryReinterpretA...
method TryDipatch (line 245) | bool IClickHouseTableColumn.TryDipatch<T>(IClickHouseTableColumnDispat...
method GetValueIndex (line 251) | private int GetValueIndex(int index)
FILE: src/Octonica.ClickHouseClient/Types/LowCardinalityTypeInfo.cs
class LowCardinalityTypeInfo (line 29) | internal sealed class LowCardinalityTypeInfo : IClickHouseColumnTypeInfo
method LowCardinalityTypeInfo (line 39) | public LowCardinalityTypeInfo()
method LowCardinalityTypeInfo (line 45) | private LowCardinalityTypeInfo(IClickHouseColumnTypeInfo baseType)
method CreateColumnReader (line 51) | public IClickHouseColumnReader CreateColumnReader(int rowCount)
method CreateColumnReader (line 57) | IClickHouseColumnReader IClickHouseColumnTypeInfo.CreateColumnReader(i...
method CreateSkippingColumnReader (line 65) | public IClickHouseColumnReaderBase CreateSkippingColumnReader(int rowC...
method CreateSkippingColumnReader (line 71) | IClickHouseColumnReaderBase IClickHouseColumnTypeInfo.CreateSkippingCo...
method GetBaseTypeInfo (line 79) | private (IClickHouseColumnTypeInfo baseType, bool isNullable) GetBaseT...
method CreateColumnWriter (line 96) | public IClickHouseColumnWriter CreateColumnWriter<T>(string columnName...
method CreateColumnWriter (line 113) | private LowCardinalityColumnWriter CreateColumnWriter<T>(
method CreateParameterWriter (line 167) | public IClickHouseParameterWriter<T> CreateParameterWriter<T>()
method GetDetailedTypeInfo (line 175) | public IClickHouseColumnTypeInfo GetDetailedTypeInfo(List<ReadOnlyMemo...
method GetFieldType (line 187) | public Type GetFieldType()
method GetDbType (line 195) | public ClickHouseDbType GetDbType()
method GetGenericArgument (line 203) | public IClickHouseTypeInfo GetGenericArgument(int index)
class LowCardinalityColumnReader (line 214) | private sealed class LowCardinalityColumnReader : IClickHouseColumnReader
method LowCardinalityColumnReader (line 227) | public LowCardinalityColumnReader(int rowCount, IClickHouseColumnTyp...
method ReadPrefix (line 234) | SequenceSize IClickHouseColumnReaderBase.ReadPrefix(ReadOnlySequence...
method ReadNext (line 239) | public SequenceSize ReadNext(ReadOnlySequence<byte> sequence)
method EndRead (line 299) | public IClickHouseTableColumn EndRead(ClickHouseColumnSettings? sett...
method ReadPrefix (line 321) | public static SequenceSize ReadPrefix(ReadOnlySequence<byte> sequence)
method TryReadHeader (line 342) | public static (int keySize, int keyCount, int bytesRead)? TryReadHea...
class LowCardinalitySkippingColumnReader (line 386) | private sealed class LowCardinalitySkippingColumnReader : IClickHouseC...
method LowCardinalitySkippingColumnReader (line 399) | public LowCardinalitySkippingColumnReader(int rowCount, IClickHouseC...
method ReadPrefix (line 405) | SequenceSize IClickHouseColumnReaderBase.ReadPrefix(ReadOnlySequence...
method ReadNext (line 410) | public SequenceSize ReadNext(ReadOnlySequence<byte> sequence)
class LowCardinalityColumnWriter (line 467) | private sealed class LowCardinalityColumnWriter : IClickHouseColumnWriter
method LowCardinalityColumnWriter (line 481) | public LowCardinalityColumnWriter(IClickHouseColumnWriter baseWriter...
method WritePrefix (line 490) | SequenceSize IClickHouseColumnWriter.WritePrefix(Span<byte> writeTo)
method WriteNext (line 501) | public SequenceSize WriteNext(Span<byte> writeTo)
class LowCardinalityTableColumnDispatcher (line 591) | private sealed class LowCardinalityTableColumnDispatcher : IClickHouse...
method LowCardinalityTableColumnDispatcher (line 597) | public LowCardinalityTableColumnDispatcher(ReadOnlyMemory<byte> keys...
method Dispatch (line 604) | public IClickHouseTableColumn Dispatch<T>(IClickHouseTableColumn<T> ...
type KeySizeCode (line 610) | private enum KeySizeCode
FILE: src/Octonica.ClickHouseClient/Types/MapTypeInfo.cs
class MapTypeInfo (line 32) | internal sealed class MapTypeInfo : IClickHouseColumnTypeInfo
method MapTypeInfo (line 44) | public MapTypeInfo()
method MapTypeInfo (line 49) | private MapTypeInfo(IClickHouseColumnTypeInfo keyType, IClickHouseColu...
method CreateColumnReader (line 56) | public IClickHouseColumnReader CreateColumnReader(int rowCount)
method CreateColumnReader (line 65) | IClickHouseColumnReader IClickHouseColumnTypeInfo.CreateColumnReader(i...
method CreateSkippingColumnReader (line 74) | public IClickHouseColumnReaderBase CreateSkippingColumnReader(int rowC...
method CreateSkippingColumnReader (line 82) | IClickHouseColumnReaderBase IClickHouseColumnTypeInfo.CreateSkippingCo...
method CreateColumnWriter (line 90) | public IClickHouseColumnWriter CreateColumnWriter<T>(string columnName...
method CreateParameterWriter (line 126) | public IClickHouseParameterWriter<T> CreateParameterWriter<T>()
method GetDbType (line 163) | public ClickHouseDbType GetDbType()
method GetDetailedTypeInfo (line 168) | public IClickHouseColumnTypeInfo GetDetailedTypeInfo(List<ReadOnlyMemo...
method GetFieldType (line 188) | public Type GetFieldType()
method GetGenericArgument (line 200) | public IClickHouseTypeInfo GetGenericArgument(int index)
class MapReader (line 216) | private sealed class MapReader : IClickHouseColumnReader
method MapReader (line 221) | public MapReader(IClickHouseColumnReader underlyingReader, Type fiel...
method ReadPrefix (line 227) | SequenceSize IClickHouseColumnReaderBase.ReadPrefix(ReadOnlySequence...
method ReadNext (line 232) | public SequenceSize ReadNext(ReadOnlySequence<byte> sequence)
method EndRead (line 237) | public IClickHouseTableColumn EndRead(ClickHouseColumnSettings? sett...
class MapColumnDispatcher (line 245) | private sealed class MapColumnDispatcher : ITypeDispatcher<IClickHouse...
method MapColumnDispatcher (line 249) | public MapColumnDispatcher(IClickHouseTableColumn column)
method Dispatch (line 254) | public IClickHouseTableColumn Dispatch<T>()
class MapColumnWriter (line 264) | private sealed class MapColumnWriter : IClickHouseColumnWriter
method MapColumnWriter (line 272) | public MapColumnWriter(IClickHouseColumnWriter underlyingWriter)
method WritePrefix (line 283) | SequenceSize IClickHouseColumnWriter.WritePrefix(Span<byte> writeTo)
method WriteNext (line 288) | public SequenceSize WriteNext(Span<byte> writeTo)
type IDictionaryDispatcher (line 294) | private interface IDictionaryDispatcher
method Dispatch (line 296) | IClickHouseColumnWriter Dispatch(IClickHouseColumnTypeInfo underlyin...
class DictionaryDispatcher (line 299) | private sealed class DictionaryDispatcher<TKey, TValue> : IDictionaryD...
method Dispatch (line 302) | public IClickHouseColumnWriter Dispatch(IClickHouseColumnTypeInfo un...
type IDictionaryParameterWirterDispatcher (line 313) | private interface IDictionaryParameterWirterDispatcher
method Dispatch (line 315) | IClickHouseParameterWriter<T> Dispatch<T>(MapTypeInfo typeInfo);
class ParameterDictionaryDispatcher (line 318) | private sealed class ParameterDictionaryDispatcher<TDictionary, TKey, ...
method Dispatch (line 322) | public IClickHouseParameterWriter<T> Dispatch<T>(MapTypeInfo typeInfo)
class MapParameterWriter (line 336) | private sealed class MapParameterWriter<TDictionary, TKey, TValue> : I...
method MapParameterWriter (line 344) | public MapParameterWriter(MapTypeInfo mapType, IClickHouseParameterW...
method TryCreateParameterValueWriter (line 351) | public bool TryCreateParameterValueWriter(TDictionary value, bool is...
method Interpolate (line 357) | public StringBuilder Interpolate(StringBuilder queryBuilder, TDictio...
method Interpolate (line 379) | public StringBuilder Interpolate(StringBuilder queryBuilder, IClickH...
FILE: src/Octonica.ClickHouseClient/Types/NothingTableColumn.cs
class NothingTableColumn (line 23) | internal sealed class NothingTableColumn : IClickHouseTableColumn
method NothingTableColumn (line 27) | public NothingTableColumn(int rowCount)
method IsNull (line 32) | public bool IsNull(int index)
method GetValue (line 40) | public object GetValue(int index)
method TryReinterpret (line 48) | public IClickHouseTableColumn<T>? TryReinterpret<T>()
method TryDipatch (line 53) | bool IClickHouseTableColumn.TryDipatch<T>(IClickHouseTableColumnDispat...
FILE: src/Octonica.ClickHouseClient/Types/NothingTypeInfo.cs
class NothingTypeInfo (line 28) | internal sealed class NothingTypeInfo : IClickHouseColumnTypeInfo
method CreateColumnReader (line 36) | public IClickHouseColumnReader CreateColumnReader(int rowCount)
method CreateColumnReader (line 41) | IClickHouseColumnReader IClickHouseColumnTypeInfo.CreateColumnReader(i...
method CreateSkippingColumnReader (line 49) | public IClickHouseColumnReaderBase CreateSkippingColumnReader(int rowC...
method CreateSkippingColumnReader (line 54) | IClickHouseColumnReaderBase IClickHouseColumnTypeInfo.CreateSkippingCo...
method CreateColumnWriter (line 62) | public IClickHouseColumnWriter CreateColumnWriter<T>(string columnName...
method CreateParameterWriter (line 67) | public IClickHouseParameterWriter<T> CreateParameterWriter<T>()
method GetDetailedTypeInfo (line 76) | IClickHouseColumnTypeInfo IClickHouseColumnTypeInfo.GetDetailedTypeInf...
method GetFieldType (line 81) | public Type GetFieldType()
method GetDbType (line 86) | public ClickHouseDbType GetDbType()
method GetGenericArgument (line 91) | public IClickHouseTypeInfo GetGenericArgument(int index)
class NothingColumnReader (line 96) | private sealed class NothingColumnReader : IClickHouseColumnReader
method NothingColumnReader (line 102) | public NothingColumnReader(int rowCount)
method ReadNext (line 107) | public SequenceSize ReadNext(ReadOnlySequence<byte> sequence)
method EndRead (line 117) | public IClickHouseTableColumn EndRead(ClickHouseColumnSettings? sett...
class NothingColumnWriter (line 123) | private sealed class NothingColumnWriter : IClickHouseColumnWriter
method NothingColumnWriter (line 133) | public NothingColumnWriter(string columnName, string columnType, int...
method WriteNext (line 140) | public SequenceSize WriteNext(Span<byte> writeTo)
class NothingParameterWriter (line 151) | internal sealed class NothingParameterWriter : IClickHouseParameterWri...
method NothingParameterWriter (line 155) | private NothingParameterWriter()
method TryCreateParameterValueWriter (line 159) | public bool TryCreateParameterValueWriter(DBNull value, bool isNeste...
method Interpolate (line 165) | public StringBuilder Interpolate(StringBuilder queryBuilder, DBNull ...
method Interpolate (line 170) | public StringBuilder Interpolate(StringBuilder queryBuilder, IClickH...
FILE: src/Octonica.ClickHouseClient/Types/NullableTableColumn.cs
class NullableTableColumn (line 26) | internal sealed class NullableTableColumn : IClickHouseTableColumn
method NullableTableColumn (line 33) | private NullableTableColumn(BitArray? nullFlags, IClickHouseTableColum...
method IsNull (line 39) | public bool IsNull(int index)
method GetValue (line 47) | public object GetValue(int index)
method TryReinterpret (line 55) | public IClickHouseTableColumn<T>? TryReinterpret<T>()
method MakeNullableColumn (line 60) | public static IClickHouseTableColumn MakeNullableColumn(BitArray? null...
method TryMakeNullableColumn (line 68) | public static IClickHouseTableColumn<T>? TryMakeNullableColumn<T>(BitA...
method TryReinterpretAsArray (line 73) | IClickHouseArrayTableColumn<T>? IClickHouseTableColumn.TryReinterpretA...
method TryDipatch (line 78) | bool IClickHouseTableColumn.TryDipatch<T>(IClickHouseTableColumnDispat...
method TryMakeNullableArrayColumn (line 84) | public static IClickHouseArrayTableColumn<T>? TryMakeNullableArrayColu...
method TryMakeNullableColumn (line 93) | private static IClickHouseTableColumn? TryMakeNullableColumn(Type unde...
type INullableColumnDispatcher (line 122) | private interface INullableColumnDispatcher
method Dispatch (line 124) | IClickHouseTableColumn? Dispatch(BitArray? nullFlags, IClickHouseTab...
class NullableStructTableColumnDispatcher (line 127) | private sealed class NullableStructTableColumnDispatcher<TStruct> : IN...
method Dispatch (line 130) | public IClickHouseTableColumn? Dispatch(BitArray? nullFlags, IClickH...
class NullableObjTableColumnDispatcher (line 144) | private sealed class NullableObjTableColumnDispatcher<TObj> : INullabl...
method Dispatch (line 147) | public IClickHouseTableColumn? Dispatch(BitArray? nullFlags, IClickH...
class NullableTableColumnDispatcher (line 162) | private sealed class NullableTableColumnDispatcher : IClickHouseTableC...
method NullableTableColumnDispatcher (line 166) | public NullableTableColumnDispatcher(BitArray? nullFlags)
method Dispatch (line 171) | public IClickHouseTableColumn? Dispatch<T>(IClickHouseTableColumn<T>...
class NullableStructTableColumn (line 195) | internal sealed class NullableStructTableColumn<TStruct> : IClickHouseTa...
method NullableStructTableColumn (line 205) | public NullableStructTableColumn(BitArray? nullFlags, IClickHouseTable...
method IsNull (line 211) | public bool IsNull(int index)
method GetValue (line 219) | public TStruct? GetValue(int index)
method TryReinterpret (line 227) | public IClickHouseTableColumn<T>? TryReinterpret<T>()
method TryReinterpretAsArray (line 232) | IClickHouseArrayTableColumn<T>? IClickHouseTableColumn.TryReinterpretA...
method TryDipatch (line 237) | bool IClickHouseTableColumn.TryDipatch<T>(IClickHouseTableColumnDispat...
method GetValue (line 243) | object IClickHouseTableColumn.GetValue(int index)
method AsNotNullable (line 248) | public IClickHouseTableColumn<TStruct> AsNotNullable()
class NullableStructTableColumnNotNullableAdapter (line 257) | internal sealed class NullableStructTableColumnNotNullableAdapter<TStruc...
method NullableStructTableColumnNotNullableAdapter (line 267) | public NullableStructTableColumnNotNullableAdapter(BitArray nullFlags,...
method IsNull (line 273) | public bool IsNull(int index)
method GetValue (line 278) | public TStruct GetValue(int index)
method TryReinterpret (line 286) | public IClickHouseTableColumn<T>? TryReinterpret<T>()
method TryReinterpretAsArray (line 291) | IClickHouseArrayTableColumn<T>? IClickHouseTableColumn.TryReinterpretA...
method TryDipatch (line 296) | bool IClickHouseTableColumn.TryDipatch<T>(IClickHouseTableColumnDispat...
method GetValue (line 302) | object IClickHouseTableColumn.GetValue(int index)
method Unguard (line 310) | public NullableStructTableColumn<TStruct> Unguard()
class NullableObjTableColumn (line 316) | internal sealed class NullableObjTableColumn<TObj> : IClickHouseTableCol...
method NullableObjTableColumn (line 326) | public NullableObjTableColumn(BitArray nullFlags, IClickHouseTableColu...
method IsNull (line 332) | public bool IsNull(int index)
method GetValue (line 337) | public TObj? GetValue(int index)
method ReinterpretAsObj (line 345) | public NullableObjTableColumn<TRes> ReinterpretAsObj<TRes>(Func<TObj, ...
method ReinterpretAsStruct (line 357) | public NullableStructTableColumn<TRes> ReinterpretAsStruct<TRes>(Func<...
method TryReinterpret (line 369) | public IClickHouseTableColumn<T>? TryReinterpret<T>()
method TryReinterpretAsArray (line 374) | IClickHouseArrayTableColumn<T>? IClickHouseTableColumn.TryReinterpretA...
method TryDipatch (line 379) | bool IClickHouseTableColumn.TryDipatch<T>(IClickHouseTableColumnDispat...
method GetValue (line 385) | object IClickHouseTableColumn.GetValue(int index)
class NullableArrayTableColumn (line 391) | internal sealed class NullableArrayTableColumn<TElement> : IClickHouseAr...
method NullableArrayTableColumn (line 399) | public NullableArrayTableColumn(IClickHouseTableColumn reinterpretatio...
method GetValue (line 406) | public object GetValue(int index)
method IsNull (line 414) | public bool IsNull(int index)
method TryReinterpret (line 419) | public IClickHouseTableColumn<T>? TryReinterpret<T>()
method TryReinterpretAsArray (line 424) | IClickHouseArrayTableColumn<T>? IClickHouseTableColumn.TryReinterpretA...
method TryDipatch (line 429) | bool IClickHouseTableColumn.TryDipatch<T>(IClickHouseTableColumnDispat...
method CopyTo (line 435) | public int CopyTo(int index, Span<TElement> buffer, int dataOffset)
FILE: src/Octonica.ClickHouseClient/Types/NullableTypeInfo.cs
class NullableTypeInfo (line 31) | internal sealed class NullableTypeInfo : IClickHouseColumnTypeInfo
method NullableTypeInfo (line 41) | public NullableTypeInfo()
method NullableTypeInfo (line 46) | public NullableTypeInfo(IClickHouseColumnTypeInfo underlyingType)
method CreateColumnReader (line 55) | public IClickHouseColumnReader CreateColumnReader(int rowCount)
method CreateColumnReader (line 63) | IClickHouseColumnReader IClickHouseColumnTypeInfo.CreateColumnReader(i...
method CreateSkippingColumnReader (line 71) | public IClickHouseColumnReaderBase CreateSkippingColumnReader(int rowC...
method CreateSkippingColumnReader (line 79) | IClickHouseColumnReaderBase IClickHouseColumnTypeInfo.CreateSkippingCo...
method CreateColumnWriter (line 87) | public IClickHouseColumnWriter CreateColumnWriter<T>(string columnName...
method CreateParameterWriter (line 95) | public IClickHouseParameterWriter<T> CreateParameterWriter<T>()
method GetDetailedTypeInfo (line 119) | public IClickHouseColumnTypeInfo GetDetailedTypeInfo(List<ReadOnlyMemo...
method GetFieldType (line 131) | public Type GetFieldType()
method GetDbType (line 143) | public ClickHouseDbType GetDbType()
method GetGenericArgument (line 151) | public IClickHouseTypeInfo GetGenericArgument(int index)
class NullableColumnReader (line 162) | private sealed class NullableColumnReader : IClickHouseColumnReader
method NullableColumnReader (line 172) | public NullableColumnReader(int rowCount, IClickHouseColumnTypeInfo ...
method ReadNext (line 178) | public SequenceSize ReadNext(ReadOnlySequence<byte> sequence)
method EndRead (line 215) | public IClickHouseTableColumn EndRead(ClickHouseColumnSettings? sett...
class NullableSkippingColumnReader (line 222) | private sealed class NullableSkippingColumnReader : IClickHouseColumnR...
method NullableSkippingColumnReader (line 230) | public NullableSkippingColumnReader(int rowCount, IClickHouseColumnT...
method ReadNext (line 236) | public SequenceSize ReadNext(ReadOnlySequence<byte> sequence)
class NullableColumnWriter (line 265) | private sealed class NullableColumnWriter<T> : IClickHouseColumnWriter
method NullableColumnWriter (line 276) | public NullableColumnWriter(string columnName, IReadOnlyList<T> rows...
method WriteNext (line 299) | public SequenceSize WriteNext(Span<byte> writeTo)
type IValueOrDefaultListDispatcherBase (line 320) | private interface IValueOrDefaultListDispatcherBase
method Dispatch (line 322) | IClickHouseColumnWriter Dispatch(string columnName, object rows, Cli...
class ValueOrDefaultListDispatcher (line 325) | private sealed class ValueOrDefaultListDispatcher<TValue> : IValueOrDe...
method Dispatch (line 328) | public IClickHouseColumnWriter Dispatch(string columnName, object ro...
type INullableParameterWriterDispatcher (line 336) | private interface INullableParameterWriterDispatcher<T>
method Dispatch (line 338) | IClickHouseParameterWriter<T> Dispatch(NullableTypeInfo typeInfo);
class NullableStructParameterWriterDispatcher (line 341) | private sealed class NullableStructParameterWriterDispatcher<T> : INul...
method Dispatch (line 344) | public IClickHouseParameterWriter<T?> Dispatch(NullableTypeInfo type...
class NullableStructParameterWriter (line 352) | private sealed class NullableStructParameterWriter<T> : IClickHousePar...
method NullableStructParameterWriter (line 358) | public NullableStructParameterWriter(NullableTypeInfo typeIfno, ICli...
method TryCreateParameterValueWriter (line 364) | public bool TryCreateParameterValueWriter(T? value, bool isNested, [...
method Interpolate (line 375) | public StringBuilder Interpolate(StringBuilder queryBuilder, T? value)
method Interpolate (line 391) | public StringBuilder Interpolate(StringBuilder queryBuilder, IClickH...
class NullableParameterWriter (line 418) | private sealed class NullableParameterWriter<T> : IClickHouseParameter...
method NullableParameterWriter (line 423) | public NullableParameterWriter(NullableTypeInfo typeIfno, IClickHous...
method TryCreateParameterValueWriter (line 429) | public bool TryCreateParameterValueWriter(T value, bool isNested, [N...
method Interpolate (line 440) | public StringBuilder Interpolate(StringBuilder queryBuilder, T value)
method Interpolate (line 456) | public StringBuilder Interpolate(StringBuilder queryBuilder, IClickH...
FILE: src/Octonica.ClickHouseClient/Types/ObjectColumnAdapter.cs
class ObjectColumnAdapter (line 22) | internal sealed class ObjectColumnAdapter : IClickHouseReinterpretedTabl...
method ObjectColumnAdapter (line 30) | public ObjectColumnAdapter(IClickHouseTableColumn tableColumn)
method IsNull (line 35) | public bool IsNull(int index)
method GetValue (line 40) | public object GetValue(int index)
method TryReinterpret (line 45) | public IClickHouseTableCol
Condensed preview — 265 files, each showing path, character count, and a content snippet. Download the .json file or copy for the full structured content (2,089K chars).
[
{
"path": ".gitignore",
"chars": 7268,
"preview": "## Ignore Visual Studio temporary files, build results, and\n## files generated by popular Visual Studio add-ons.\n##\n## G"
},
{
"path": "CHANGELOG.md",
"chars": 13134,
"preview": "### Octonica.ClickHouseClient Next Version, Unscheduled\n\n#### New Feature\n\n* Add method `ClickHouseDataReader.ConfigureC"
},
{
"path": "LICENSE",
"chars": 11368,
"preview": "Copyright 2019-2026 Octonica\n\n Apache License\n Version 2.0, Ja"
},
{
"path": "README.md",
"chars": 3056,
"preview": "ClickHouse .NET Core driver\n===============\n\nThis is an implementation of .NET Core driver for ClickHouse in a form of A"
},
{
"path": "docs/ClickHouseColumnWriter.md",
"chars": 3292,
"preview": "# ClickHouseColumnWriter\n\n`ClickHouseColumnWriter` is a class dedicated for writing arbitrary large amount of rows to a"
},
{
"path": "docs/Parameters.md",
"chars": 6008,
"preview": "# Parameters\r\n\r\nClickHouseClient's implementation of parameters is compliant with ADO.NET. API for working with paramete"
},
{
"path": "docs/TypeMapping.md",
"chars": 2618,
"preview": "# Type mappings\n**ClickHouse type**. The type of the column.\n\n**Default type**. This is the type returned by `Octonica."
},
{
"path": "src/ConnectionSettingsHelper.cs",
"chars": 3670,
"preview": "#region License Apache 2.0\n/* Copyright 2020-2023 Octonica\n *\n * Licensed under the Apache License, Version 2.0 (the \"Li"
},
{
"path": "src/Octonica.ClickHouseClient/ClickHouseBinaryProtocolReader.cs",
"chars": 16825,
"preview": "#region License Apache 2.0\n/* Copyright 2019-2021, 2023 Octonica\n *\n * Licensed under the Apache License, Version 2.0 ("
},
{
"path": "src/Octonica.ClickHouseClient/ClickHouseBinaryProtocolWriter.cs",
"chars": 11047,
"preview": "#region License Apache 2.0\n/* Copyright 2019-2021, 2023-2024 Octonica\n *\n * Licensed under the Apache License, Version "
},
{
"path": "src/Octonica.ClickHouseClient/ClickHouseColumnSettings.cs",
"chars": 4990,
"preview": "#region License Apache 2.0\n/* Copyright 2019-2021 Octonica\n *\n * Licensed under the Apache License, Version 2.0 (the \"L"
},
{
"path": "src/Octonica.ClickHouseClient/ClickHouseColumnWriter.cs",
"chars": 68292,
"preview": "#region License Apache 2.0\n/* Copyright 2019-2021, 2023 Octonica\n *\n * Licensed under the Apache License, Version 2.0 ("
},
{
"path": "src/Octonica.ClickHouseClient/ClickHouseCommand.cs",
"chars": 53186,
"preview": "#region License Apache 2.0\n/* Copyright 2019-2026 Octonica\n *\n * Licensed under the Apache License, Version 2.0 (the \"L"
},
{
"path": "src/Octonica.ClickHouseClient/ClickHouseConnection.cs",
"chars": 49559,
"preview": "#region License Apache 2.0\r\n/* Copyright 2019-2024 Octonica\r\n *\r\n * Licensed under the Apache License, Version 2.0 (the"
},
{
"path": "src/Octonica.ClickHouseClient/ClickHouseConnectionSettings.cs",
"chars": 7679,
"preview": "#region License Apache 2.0\n/* Copyright 2019-2023 Octonica\n *\n * Licensed under the Apache License, Version 2.0 (the \"L"
},
{
"path": "src/Octonica.ClickHouseClient/ClickHouseConnectionState.cs",
"chars": 1375,
"preview": "#region License Apache 2.0\n/* Copyright 2020-2021 Octonica\n *\n * Licensed under the Apache License, Version 2.0 (the \"L"
},
{
"path": "src/Octonica.ClickHouseClient/ClickHouseConnectionStringBuilder.cs",
"chars": 18450,
"preview": "#region License Apache 2.0\n/* Copyright 2019-2023 Octonica\n *\n * Licensed under the Apache License, Version 2.0 (the \"L"
},
{
"path": "src/Octonica.ClickHouseClient/ClickHouseDataReader.cs",
"chars": 60596,
"preview": "#region License Apache 2.0\n/* Copyright 2019-2021, 2024, 2026 Octonica\n *\n * Licensed under the Apache License, Version"
},
{
"path": "src/Octonica.ClickHouseClient/ClickHouseDataReaderBase.cs",
"chars": 1887,
"preview": "#region License Apache 2.0\n/* Copyright 2019-2021 Octonica\n *\n * Licensed under the Apache License, Version 2.0 (the \"L"
},
{
"path": "src/Octonica.ClickHouseClient/ClickHouseDataReaderRowLimit.cs",
"chars": 806,
"preview": "#region License Apache 2.0\n/* Copyright 2021 Octonica\n *\n * Licensed under the Apache License, Version 2.0 (the \"Licens"
},
{
"path": "src/Octonica.ClickHouseClient/ClickHouseDataReaderState.cs",
"chars": 2757,
"preview": "#region License Apache 2.0\n/* Copyright 2020-2021 Octonica\n *\n * Licensed under the Apache License, Version 2.0 (the \"L"
},
{
"path": "src/Octonica.ClickHouseClient/ClickHouseDbProviderFactory.cs",
"chars": 2291,
"preview": "#region License Apache 2.0\n/* Copyright 2020-2021 Octonica\n *\n * Licensed under the Apache License, Version 2.0 (the \"L"
},
{
"path": "src/Octonica.ClickHouseClient/ClickHouseDbType.cs",
"chars": 10191,
"preview": "#region License Apache 2.0\n/* Copyright 2020-2021, 2024 Octonica\n *\n * Licensed under the Apache License, Version 2.0 ("
},
{
"path": "src/Octonica.ClickHouseClient/ClickHouseFlushMode.cs",
"chars": 1997,
"preview": "#region License Apache 2.0\n/* Copyright 2023 Octonica\n *\n * Licensed under the Apache License, Version 2.0 (the \"Licens"
},
{
"path": "src/Octonica.ClickHouseClient/ClickHouseParameter.cs",
"chars": 22866,
"preview": "#region License Apache 2.0\n/* Copyright 2019-2023 Octonica\n *\n * Licensed under the Apache License, Version 2.0 (the \"L"
},
{
"path": "src/Octonica.ClickHouseClient/ClickHouseParameterCollection.cs",
"chars": 21467,
"preview": "#region License Apache 2.0\n/* Copyright 2019-2021, 2024 Octonica\n *\n * Licensed under the Apache License, Version 2.0 ("
},
{
"path": "src/Octonica.ClickHouseClient/ClickHouseParameterMode.cs",
"chars": 3026,
"preview": "#region License Apache 2.0\r\n/* Copyright 2022-2023 Octonica\r\n *\r\n * Licensed under the Apache License, Version 2.0 (the"
},
{
"path": "src/Octonica.ClickHouseClient/ClickHousePasswordComplexityRule.cs",
"chars": 1643,
"preview": "#region License Apache 2.0\n/* Copyright 2023 Octonica\n *\n * Licensed under the Apache License, Version 2.0 (the \"Licens"
},
{
"path": "src/Octonica.ClickHouseClient/ClickHouseQueryExecutionProgress.cs",
"chars": 2489,
"preview": "#region License Apache 2.0\r\n/* Copyright 2026 Octonica\r\n *\r\n * Licensed under the Apache License, Version 2.0 (the \"Lic"
},
{
"path": "src/Octonica.ClickHouseClient/ClickHouseReaderColumnSettings.cs",
"chars": 3012,
"preview": "#region License Apache 2.0\r\n/* Copyright 2024 Octonica\r\n *\r\n * Licensed under the Apache License, Version 2.0 (the \"Lic"
},
{
"path": "src/Octonica.ClickHouseClient/ClickHouseServerInfo.cs",
"chars": 4448,
"preview": "#region License Apache 2.0\n/* Copyright 2019-2021, 2023 Octonica\n *\n * Licensed under the Apache License, Version 2.0 ("
},
{
"path": "src/Octonica.ClickHouseClient/ClickHouseTable.cs",
"chars": 1219,
"preview": "#region License Apache 2.0\n/* Copyright 2019-2021 Octonica\n *\n * Licensed under the Apache License, Version 2.0 (the \"L"
},
{
"path": "src/Octonica.ClickHouseClient/ClickHouseTableColumn.cs",
"chars": 4114,
"preview": "#region License Apache 2.0\n/* Copyright 2021 Octonica\n *\n * Licensed under the Apache License, Version 2.0 (the \"Licens"
},
{
"path": "src/Octonica.ClickHouseClient/ClickHouseTableColumnCollection.cs",
"chars": 10314,
"preview": "#region License Apache 2.0\n/* Copyright 2021 Octonica\n *\n * Licensed under the Apache License, Version 2.0 (the \"Licens"
},
{
"path": "src/Octonica.ClickHouseClient/ClickHouseTableProvider.cs",
"chars": 3935,
"preview": "#region License Apache 2.0\n/* Copyright 2021 Octonica\n *\n * Licensed under the Apache License, Version 2.0 (the \"Licens"
},
{
"path": "src/Octonica.ClickHouseClient/ClickHouseTableProviderCollection.cs",
"chars": 1892,
"preview": "#region License Apache 2.0\n/* Copyright 2021 Octonica\n *\n * Licensed under the Apache License, Version 2.0 (the \"Licens"
},
{
"path": "src/Octonica.ClickHouseClient/ClickHouseTableWriter.cs",
"chars": 1664,
"preview": "#region License Apache 2.0\n/* Copyright 2019-2020 Octonica\n *\n * Licensed under the Apache License, Version 2.0 (the \"L"
},
{
"path": "src/Octonica.ClickHouseClient/ClickHouseTcpClient.cs",
"chars": 30180,
"preview": "#region License Apache 2.0\n/* Copyright 2019-2021, 2023-2024 Octonica\n *\n * Licensed under the Apache License, Version "
},
{
"path": "src/Octonica.ClickHouseClient/ClickHouseTcpClientState.cs",
"chars": 1096,
"preview": "#region License Apache 2.0\n/* Copyright 2021 Octonica\n *\n * Licensed under the Apache License, Version 2.0 (the \"Licens"
},
{
"path": "src/Octonica.ClickHouseClient/ClickHouseTlsMode.cs",
"chars": 1273,
"preview": "#region License Apache 2.0\n/* Copyright 2021 Octonica\n *\n * Licensed under the Apache License, Version 2.0 (the \"Licens"
},
{
"path": "src/Octonica.ClickHouseClient/ClickHouseVersion.cs",
"chars": 6429,
"preview": "#region License Apache 2.0\n/* Copyright 2019-2021 Octonica\n *\n * Licensed under the Apache License, Version 2.0 (the \"L"
},
{
"path": "src/Octonica.ClickHouseClient/Exceptions/ClickHouseErrorCodes.cs",
"chars": 5869,
"preview": "#region License Apache 2.0\n/* Copyright 2019-2021, 2023 Octonica\n *\n * Licensed under the Apache License, Version 2.0 ("
},
{
"path": "src/Octonica.ClickHouseClient/Exceptions/ClickHouseException.cs",
"chars": 5349,
"preview": "#region License Apache 2.0\n/* Copyright 2019-2021 Octonica\n *\n * Licensed under the Apache License, Version 2.0 (the \"Li"
},
{
"path": "src/Octonica.ClickHouseClient/Exceptions/ClickHouseHandledException.cs",
"chars": 1641,
"preview": "#region License Apache 2.0\n/* Copyright 2019-2021 Octonica\n *\n * Licensed under the Apache License, Version 2.0 (the \"L"
},
{
"path": "src/Octonica.ClickHouseClient/Exceptions/ClickHouseServerException.cs",
"chars": 5433,
"preview": "#region License Apache 2.0\n/* Copyright 2019-2021 Octonica\n *\n * Licensed under the Apache License, Version 2.0 (the \"L"
},
{
"path": "src/Octonica.ClickHouseClient/IClickHouseArrayTableColumn.cs",
"chars": 1476,
"preview": "#region License Apache 2.0\n/* Copyright 2021 Octonica\n *\n * Licensed under the Apache License, Version 2.0 (the \"Licens"
},
{
"path": "src/Octonica.ClickHouseClient/IClickHouseColumnDescriptor.cs",
"chars": 1212,
"preview": "#region License Apache 2.0\n/* Copyright 2021-2022 Octonica\n *\n * Licensed under the Apache License, Version 2.0 (the \"L"
},
{
"path": "src/Octonica.ClickHouseClient/IClickHouseSessionExternalResources.cs",
"chars": 903,
"preview": "#region License Apache 2.0\n/* Copyright 2021 Octonica\n *\n * Licensed under the Apache License, Version 2.0 (the \"Licens"
},
{
"path": "src/Octonica.ClickHouseClient/IClickHouseTableColumn.cs",
"chars": 4713,
"preview": "#region License Apache 2.0\n/* Copyright 2019-2021, 2024 Octonica\n *\n * Licensed under the Apache License, Version 2.0 ("
},
{
"path": "src/Octonica.ClickHouseClient/IClickHouseTableColumnDispatcher.cs",
"chars": 1354,
"preview": "#region License Apache 2.0\n/* Copyright 2021 Octonica\n *\n * Licensed under the Apache License, Version 2.0 (the \"Licens"
},
{
"path": "src/Octonica.ClickHouseClient/IClickHouseTableProvider.cs",
"chars": 2216,
"preview": "#region License Apache 2.0\n/* Copyright 2021 Octonica\n *\n * Licensed under the Apache License, Version 2.0 (the \"Licens"
},
{
"path": "src/Octonica.ClickHouseClient/Octonica.ClickHouseClient.csproj",
"chars": 1481,
"preview": "<Project Sdk=\"Microsoft.NET.Sdk\">\n\n <PropertyGroup>\n <TargetFrameworks>netcoreapp3.1;net6.0;net8.0</TargetFramework"
},
{
"path": "src/Octonica.ClickHouseClient/Properties/AssemblyInfo.cs",
"chars": 735,
"preview": "#region License Apache 2.0\n/* Copyright 2019-2020 Octonica\n *\n * Licensed under the Apache License, Version 2.0 (the \"L"
},
{
"path": "src/Octonica.ClickHouseClient/Protocol/BlockFieldCodes.cs",
"chars": 1668,
"preview": "#region License Apache 2.0\n/* Copyright 2019-2021 Octonica\n *\n * Licensed under the Apache License, Version 2.0 (the \"L"
},
{
"path": "src/Octonica.ClickHouseClient/Protocol/BlockHeader.cs",
"chars": 1276,
"preview": "#region License Apache 2.0\n/* Copyright 2019-2020 Octonica\n *\n * Licensed under the Apache License, Version 2.0 (the \"L"
},
{
"path": "src/Octonica.ClickHouseClient/Protocol/CityHash.cs",
"chars": 13655,
"preview": "#region License\n// Copyright (c) 2011 Google, Inc.\n//\n// Permission is hereby granted, free of charge, to any person ob"
},
{
"path": "src/Octonica.ClickHouseClient/Protocol/ClickHouseEmptyTableWriter.cs",
"chars": 1207,
"preview": "#region License Apache 2.0\n/* Copyright 2019-2020 Octonica\n *\n * Licensed under the Apache License, Version 2.0 (the \"L"
},
{
"path": "src/Octonica.ClickHouseClient/Protocol/ClickHouseParameterWriter.cs",
"chars": 3962,
"preview": "#region License Apache 2.0\n/* Copyright 2023 Octonica\n *\n * Licensed under the Apache License, Version 2.0 (the \"Licens"
},
{
"path": "src/Octonica.ClickHouseClient/Protocol/ClickHouseProtocolRevisions.cs",
"chars": 4336,
"preview": "#region License Apache 2.0\n/* Copyright 2019-2023 Octonica\n *\n * Licensed under the Apache License, Version 2.0 (the \"L"
},
{
"path": "src/Octonica.ClickHouseClient/Protocol/ClickHouseSyntaxHelper.cs",
"chars": 7038,
"preview": "#region License Apache 2.0\n/* Copyright 2021 Octonica\n *\n * Licensed under the Apache License, Version 2.0 (the \"Licens"
},
{
"path": "src/Octonica.ClickHouseClient/Protocol/ClientHelloMessage.cs",
"chars": 3683,
"preview": "#region License Apache 2.0\n/* Copyright 2019-2020, 2024 Octonica\n *\n * Licensed under the Apache License, Version 2.0 ("
},
{
"path": "src/Octonica.ClickHouseClient/Protocol/ClientMessageCode.cs",
"chars": 821,
"preview": "#region License Apache 2.0\n/* Copyright 2019-2021 Octonica\n *\n * Licensed under the Apache License, Version 2.0 (the \"L"
},
{
"path": "src/Octonica.ClickHouseClient/Protocol/ClientQueryMessage.cs",
"chars": 10428,
"preview": "#region License Apache 2.0\n/* Copyright 2019-2021, 2023, 2025 Octonica\n *\n * Licensed under the Apache License, Version"
},
{
"path": "src/Octonica.ClickHouseClient/Protocol/ColumnInfo.cs",
"chars": 1011,
"preview": "#region License Apache 2.0\n/* Copyright 2019-2020 Octonica\n *\n * Licensed under the Apache License, Version 2.0 (the \"L"
},
{
"path": "src/Octonica.ClickHouseClient/Protocol/CompressionAlgorithm.cs",
"chars": 764,
"preview": "#region License Apache 2.0\n/* Copyright 2019-2021 Octonica\n *\n * Licensed under the Apache License, Version 2.0 (the \"L"
},
{
"path": "src/Octonica.ClickHouseClient/Protocol/CompressionDecoderBase.cs",
"chars": 6998,
"preview": "#region License Apache 2.0\n/* Copyright 2019-2020 Octonica\n *\n * Licensed under the Apache License, Version 2.0 (the \"L"
},
{
"path": "src/Octonica.ClickHouseClient/Protocol/CompressionEncoderBase.cs",
"chars": 11895,
"preview": "#region License Apache 2.0\n/* Copyright 2019-2020, 2023 Octonica\n *\n * Licensed under the Apache License, Version 2.0 ("
},
{
"path": "src/Octonica.ClickHouseClient/Protocol/IClickHouseColumnReader.cs",
"chars": 1285,
"preview": "#region License Apache 2.0\n/* Copyright 2019-2021 Octonica\n *\n * Licensed under the Apache License, Version 2.0 (the \"L"
},
{
"path": "src/Octonica.ClickHouseClient/Protocol/IClickHouseColumnReaderBase.cs",
"chars": 1884,
"preview": "#region License Apache 2.0\n/* Copyright 2021, 2024 Octonica\n *\n * Licensed under the Apache License, Version 2.0 (the \""
},
{
"path": "src/Octonica.ClickHouseClient/Protocol/IClickHouseColumnWriter.cs",
"chars": 2100,
"preview": "#region License Apache 2.0\n/* Copyright 2019-2021, 2024 Octonica\n *\n * Licensed under the Apache License, Version 2.0 ("
},
{
"path": "src/Octonica.ClickHouseClient/Protocol/IClickHouseColumnWriterFactory.cs",
"chars": 804,
"preview": "#region License Apache 2.0\n/* Copyright 2021 Octonica\n *\n * Licensed under the Apache License, Version 2.0 (the \"Licens"
},
{
"path": "src/Octonica.ClickHouseClient/Protocol/IClickHouseParameterValueWriter.cs",
"chars": 1764,
"preview": "#region License Apache 2.0\n/* Copyright 2023 Octonica\n *\n * Licensed under the Apache License, Version 2.0 (the \"Licens"
},
{
"path": "src/Octonica.ClickHouseClient/Protocol/IClickHouseParameterWriter.cs",
"chars": 4013,
"preview": "#region License Apache 2.0\n/* Copyright 2023 Octonica\n *\n * Licensed under the Apache License, Version 2.0 (the \"Licens"
},
{
"path": "src/Octonica.ClickHouseClient/Protocol/IClickHouseTableWriter.cs",
"chars": 902,
"preview": "#region License Apache 2.0\n/* Copyright 2019-2021 Octonica\n *\n * Licensed under the Apache License, Version 2.0 (the \"L"
},
{
"path": "src/Octonica.ClickHouseClient/Protocol/IClientMessage.cs",
"chars": 836,
"preview": "#region License Apache 2.0\n/* Copyright 2019-2020 Octonica\n *\n * Licensed under the Apache License, Version 2.0 (the \"L"
},
{
"path": "src/Octonica.ClickHouseClient/Protocol/IServerMessage.cs",
"chars": 776,
"preview": "#region License Apache 2.0\n/* Copyright 2019-2020 Octonica\n *\n * Licensed under the Apache License, Version 2.0 (the \"L"
},
{
"path": "src/Octonica.ClickHouseClient/Protocol/Lz4CompressionDecoder.cs",
"chars": 1283,
"preview": "#region License Apache 2.0\n/* Copyright 2019-2020 Octonica\n *\n * Licensed under the Apache License, Version 2.0 (the \"L"
},
{
"path": "src/Octonica.ClickHouseClient/Protocol/Lz4CompressionEncoder.cs",
"chars": 3054,
"preview": "#region License Apache 2.0\n/* Copyright 2019-2020 Octonica\n *\n * Licensed under the Apache License, Version 2.0 (the \"L"
},
{
"path": "src/Octonica.ClickHouseClient/Protocol/QueryKind.cs",
"chars": 793,
"preview": "#region License Apache 2.0\n/* Copyright 2019-2020 Octonica\n *\n * Licensed under the Apache License, Version 2.0 (the \"L"
},
{
"path": "src/Octonica.ClickHouseClient/Protocol/SequenceSize.cs",
"chars": 4324,
"preview": "#region License Apache 2.0\n/* Copyright 2019-2021 Octonica\n *\n * Licensed under the Apache License, Version 2.0 (the \"L"
},
{
"path": "src/Octonica.ClickHouseClient/Protocol/ServerDataMessage.cs",
"chars": 1544,
"preview": "#region License Apache 2.0\n/* Copyright 2019-2020 Octonica\n *\n * Licensed under the Apache License, Version 2.0 (the \"L"
},
{
"path": "src/Octonica.ClickHouseClient/Protocol/ServerEndOfStreamMessage.cs",
"chars": 1002,
"preview": "#region License Apache 2.0\n/* Copyright 2019-2020 Octonica\n *\n * Licensed under the Apache License, Version 2.0 (the \"L"
},
{
"path": "src/Octonica.ClickHouseClient/Protocol/ServerErrorMessage.cs",
"chars": 2248,
"preview": "#region License Apache 2.0\n/* Copyright 2019-2020 Octonica\n *\n * Licensed under the Apache License, Version 2.0 (the \"L"
},
{
"path": "src/Octonica.ClickHouseClient/Protocol/ServerHelloMessage.cs",
"chars": 3779,
"preview": "#region License Apache 2.0\n/* Copyright 2019-2020, 2023 Octonica\n *\n * Licensed under the Apache License, Version 2.0 ("
},
{
"path": "src/Octonica.ClickHouseClient/Protocol/ServerMessageCode.cs",
"chars": 1193,
"preview": "#region License Apache 2.0\n/* Copyright 2019-2021, 2023 Octonica\n *\n * Licensed under the Apache License, Version 2.0 ("
},
{
"path": "src/Octonica.ClickHouseClient/Protocol/ServerPongMessage.cs",
"chars": 962,
"preview": "#region License Apache 2.0\n/* Copyright 2021 Octonica\n *\n * Licensed under the Apache License, Version 2.0 (the \"Licens"
},
{
"path": "src/Octonica.ClickHouseClient/Protocol/ServerProfileInfoMessage.cs",
"chars": 2377,
"preview": "#region License Apache 2.0\n/* Copyright 2019-2020 Octonica\n *\n * Licensed under the Apache License, Version 2.0 (the \"L"
},
{
"path": "src/Octonica.ClickHouseClient/Protocol/ServerProgressMessage.cs",
"chars": 2522,
"preview": "#region License Apache 2.0\n/* Copyright 2019-2020, 2023, 2026 Octonica\n *\n * Licensed under the Apache License, Version"
},
{
"path": "src/Octonica.ClickHouseClient/Protocol/ServerTableColumnsMessage.cs",
"chars": 1424,
"preview": "#region License Apache 2.0\n/* Copyright 2019-2020 Octonica\n *\n * Licensed under the Apache License, Version 2.0 (the \"L"
},
{
"path": "src/Octonica.ClickHouseClient/Protocol/ServerTimeZoneUpdateMessage.cs",
"chars": 1370,
"preview": "#region License Apache 2.0\n/* Copyright 2023 Octonica\n *\n * Licensed under the Apache License, Version 2.0 (the \"Licens"
},
{
"path": "src/Octonica.ClickHouseClient/Protocol/StateCodes.cs",
"chars": 767,
"preview": "#region License Apache 2.0\n/* Copyright 2019-2020 Octonica\n *\n * Licensed under the Apache License, Version 2.0 (the \"L"
},
{
"path": "src/Octonica.ClickHouseClient/Protocol/UnknownServerMessage.cs",
"chars": 931,
"preview": "#region License Apache 2.0\n/* Copyright 2020 Octonica\n *\n * Licensed under the Apache License, Version 2.0 (the \"Licens"
},
{
"path": "src/Octonica.ClickHouseClient/Types/ArrayTableColumn.cs",
"chars": 6320,
"preview": "#region License Apache 2.0\n/* Copyright 2019-2021, 2024 Octonica\n *\n * Licensed under the Apache License, Version 2.0 ("
},
{
"path": "src/Octonica.ClickHouseClient/Types/ArrayTypeInfo.cs",
"chars": 41787,
"preview": "#region License Apache 2.0\n/* Copyright 2019-2021, 2023-2024 Octonica\n *\n * Licensed under the Apache License, Version "
},
{
"path": "src/Octonica.ClickHouseClient/Types/BigIntegerTableColumn.cs",
"chars": 2346,
"preview": "#region License Apache 2.0\n/* Copyright 2021, 2024 Octonica\n *\n * Licensed under the Apache License, Version 2.0 (the \""
},
{
"path": "src/Octonica.ClickHouseClient/Types/BigIntegerTypeInfoBase.cs",
"chars": 9678,
"preview": "#region License Apache 2.0\n/* Copyright 2019-2021, 2023 Octonica\n *\n * Licensed under the Apache License, Version 2.0 ("
},
{
"path": "src/Octonica.ClickHouseClient/Types/BoolTableColumn.cs",
"chars": 2124,
"preview": "#region License Apache 2.0\r\n/* Copyright 2022, 2024 Octonica\r\n *\r\n * Licensed under the Apache License, Version 2.0 (th"
},
{
"path": "src/Octonica.ClickHouseClient/Types/BoolTypeInfo.cs",
"chars": 4581,
"preview": "#region License Apache 2.0\r\n/* Copyright 2022-2023 Octonica\r\n *\r\n * Licensed under the Apache License, Version 2.0 (the"
},
{
"path": "src/Octonica.ClickHouseClient/Types/ClickHouseColumnReinterpreter.cs",
"chars": 20161,
"preview": "#region License Apache 2.0\r\n/* Copyright 2024, 2026 Octonica\r\n *\r\n * Licensed under the Apache License, Version 2.0 (th"
},
{
"path": "src/Octonica.ClickHouseClient/Types/ClickHouseColumnSerializationMode.cs",
"chars": 1627,
"preview": "#region License Apache 2.0\r\n/* Copyright 2024 Octonica\r\n *\r\n * Licensed under the Apache License, Version 2.0 (the \"Lic"
},
{
"path": "src/Octonica.ClickHouseClient/Types/ClickHouseEnumConverter.cs",
"chars": 2825,
"preview": "#region License Apache 2.0\n/* Copyright 2020-2021 Octonica\n *\n * Licensed under the Apache License, Version 2.0 (the \"L"
},
{
"path": "src/Octonica.ClickHouseClient/Types/ClickHouseTableColumnHelper.cs",
"chars": 1494,
"preview": "#region License Apache 2.0\n/* Copyright 2021 Octonica\n *\n * Licensed under the Apache License, Version 2.0 (the \"Licens"
},
{
"path": "src/Octonica.ClickHouseClient/Types/ClickHouseTypeInfoProvider.cs",
"chars": 28339,
"preview": "#region License Apache 2.0\n/* Copyright 2019-2022, 2024 Octonica\n *\n * Licensed under the Apache License, Version 2.0 ("
},
{
"path": "src/Octonica.ClickHouseClient/Types/CustomSerializationColumnReader.cs",
"chars": 8008,
"preview": "#region License Apache 2.0\r\n/* Copyright 2024 Octonica\r\n *\r\n * Licensed under the Apache License, Version 2.0 (the \"Lic"
},
{
"path": "src/Octonica.ClickHouseClient/Types/CustomSerializationSkippingColumnReader.cs",
"chars": 6091,
"preview": "#region License Apache 2.0\r\n/* Copyright 2024 Octonica\r\n *\r\n * Licensed under the Apache License, Version 2.0 (the \"Lic"
},
{
"path": "src/Octonica.ClickHouseClient/Types/Date32TableColumn.Net6.0.cs",
"chars": 2040,
"preview": "#region License Apache 2.0\n/* Copyright 2021, 2024 Octonica\n *\n * Licensed under the Apache License, Version 2.0 (the \""
},
{
"path": "src/Octonica.ClickHouseClient/Types/Date32TableColumn.NetCoreApp3.1.cs",
"chars": 1453,
"preview": "#region License Apache 2.0\n/* Copyright 2021, 2024 Octonica\n *\n * Licensed under the Apache License, Version 2.0 (the \""
},
{
"path": "src/Octonica.ClickHouseClient/Types/Date32TableColumn.cs",
"chars": 1440,
"preview": "#region License Apache 2.0\n/* Copyright 2021, 2024 Octonica\n *\n * Licensed under the Apache License, Version 2.0 (the \""
},
{
"path": "src/Octonica.ClickHouseClient/Types/Date32TypeInfo.Net6.0.cs",
"chars": 5974,
"preview": "#region License Apache 2.0\n/* Copyright 2021, 2023 Octonica\n *\n * Licensed under the Apache License, Version 2.0 (the \""
},
{
"path": "src/Octonica.ClickHouseClient/Types/Date32TypeInfo.NetCoreApp3.1.cs",
"chars": 3318,
"preview": "#region License Apache 2.0\n/* Copyright 2021, 2023-2024 Octonica\n *\n * Licensed under the Apache License, Version 2.0 ("
},
{
"path": "src/Octonica.ClickHouseClient/Types/Date32TypeInfo.cs",
"chars": 4271,
"preview": "#region License Apache 2.0\n/* Copyright 2021, 2023-2024 Octonica\n *\n * Licensed under the Apache License, Version 2.0 ("
},
{
"path": "src/Octonica.ClickHouseClient/Types/DateOnlyTableColumn.cs",
"chars": 1535,
"preview": "#region License Apache 2.0\n/* Copyright 2021 Octonica\n *\n * Licensed under the Apache License, Version 2.0 (the \"Licens"
},
{
"path": "src/Octonica.ClickHouseClient/Types/DateTime64TableColumn.cs",
"chars": 5383,
"preview": "#region License Apache 2.0\n/* Copyright 2020-2021, 2024 Octonica\n *\n * Licensed under the Apache License, Version 2.0 ("
},
{
"path": "src/Octonica.ClickHouseClient/Types/DateTime64TypeInfo.cs",
"chars": 17477,
"preview": "#region License Apache 2.0\n/* Copyright 2020-2024 Octonica\n *\n * Licensed under the Apache License, Version 2.0 (the \"L"
},
{
"path": "src/Octonica.ClickHouseClient/Types/DateTimeTableColumn.cs",
"chars": 2713,
"preview": "#region License Apache 2.0\n/* Copyright 2019-2021, 2024 Octonica\n *\n * Licensed under the Apache License, Version 2.0 ("
},
{
"path": "src/Octonica.ClickHouseClient/Types/DateTimeTypeInfo.cs",
"chars": 11242,
"preview": "#region License Apache 2.0\n/* Copyright 2019-2023 Octonica\n *\n * Licensed under the Apache License, Version 2.0 (the \"L"
},
{
"path": "src/Octonica.ClickHouseClient/Types/DateTypeInfo.Net6.0.cs",
"chars": 6294,
"preview": "#region License Apache 2.0\n/* Copyright 2021, 2023 Octonica\n *\n * Licensed under the Apache License, Version 2.0 (the \""
},
{
"path": "src/Octonica.ClickHouseClient/Types/DateTypeInfo.NetCoreApp3.1.cs",
"chars": 3615,
"preview": "#region License Apache 2.0\n/* Copyright 2019-2021, 2023 Octonica\n *\n * Licensed under the Apache License, Version 2.0 ("
},
{
"path": "src/Octonica.ClickHouseClient/Types/DateTypeInfo.cs",
"chars": 3766,
"preview": "#region License Apache 2.0\n/* Copyright 2019-2021, 2023 Octonica\n *\n * Licensed under the Apache License, Version 2.0 ("
},
{
"path": "src/Octonica.ClickHouseClient/Types/Decimal128TypeInfo.cs",
"chars": 1927,
"preview": "#region License Apache 2.0\n/* Copyright 2019-2021 Octonica\n *\n * Licensed under the Apache License, Version 2.0 (the \"L"
},
{
"path": "src/Octonica.ClickHouseClient/Types/Decimal32TypeInfo.cs",
"chars": 1921,
"preview": "#region License Apache 2.0\n/* Copyright 2019-2021 Octonica\n *\n * Licensed under the Apache License, Version 2.0 (the \"L"
},
{
"path": "src/Octonica.ClickHouseClient/Types/Decimal64TypeInfo.cs",
"chars": 1922,
"preview": "#region License Apache 2.0\n/* Copyright 2019-2021 Octonica\n *\n * Licensed under the Apache License, Version 2.0 (the \"L"
},
{
"path": "src/Octonica.ClickHouseClient/Types/DecimalTableColumn.cs",
"chars": 7145,
"preview": "#region License Apache 2.0\n/* Copyright 2019-2021, 2024 Octonica\n *\n * Licensed under the Apache License, Version 2.0 ("
},
{
"path": "src/Octonica.ClickHouseClient/Types/DecimalTypeInfo.cs",
"chars": 1477,
"preview": "#region License Apache 2.0\n/* Copyright 2019-2021 Octonica\n *\n * Licensed under the Apache License, Version 2.0 (the \"L"
},
{
"path": "src/Octonica.ClickHouseClient/Types/DecimalTypeInfoBase.cs",
"chars": 25131,
"preview": "#region License Apache 2.0\n/* Copyright 2019-2021, 2023 Octonica\n *\n * Licensed under the Apache License, Version 2.0 ("
},
{
"path": "src/Octonica.ClickHouseClient/Types/EmptyParameterValueWriter.cs",
"chars": 1114,
"preview": "#region License Apache 2.0\n/* Copyright 2023 Octonica\n *\n * Licensed under the Apache License, Version 2.0 (the \"Licens"
},
{
"path": "src/Octonica.ClickHouseClient/Types/Enum16TypeInfo.cs",
"chars": 5624,
"preview": "#region License Apache 2.0\n/* Copyright 2020-2021, 2023 Octonica\n *\n * Licensed under the Apache License, Version 2.0 ("
},
{
"path": "src/Octonica.ClickHouseClient/Types/Enum8TypeInfo.cs",
"chars": 4920,
"preview": "#region License Apache 2.0\n/* Copyright 2020-2021, 2023 Octonica\n *\n * Licensed under the Apache License, Version 2.0 ("
},
{
"path": "src/Octonica.ClickHouseClient/Types/EnumTableColumn.cs",
"chars": 5304,
"preview": "#region License Apache 2.0\n/* Copyright 2020-2021, 2024 Octonica\n *\n * Licensed under the Apache License, Version 2.0 ("
},
{
"path": "src/Octonica.ClickHouseClient/Types/EnumTypeInfoBase.cs",
"chars": 11913,
"preview": "#region License Apache 2.0\n/* Copyright 2020-2021, 2023 Octonica\n *\n * Licensed under the Apache License, Version 2.0 ("
},
{
"path": "src/Octonica.ClickHouseClient/Types/FixedStringDecodedCharArrayTableColumn.cs",
"chars": 1690,
"preview": "#region License Apache 2.0\n/* Copyright 2021, 2024 Octonica\n *\n * Licensed under the Apache License, Version 2.0 (the \""
},
{
"path": "src/Octonica.ClickHouseClient/Types/FixedStringDecodedTableColumn.cs",
"chars": 1667,
"preview": "#region License Apache 2.0\n/* Copyright 2019-2021, 2024 Octonica\n *\n * Licensed under the Apache License, Version 2.0 ("
},
{
"path": "src/Octonica.ClickHouseClient/Types/FixedStringTableColumn.cs",
"chars": 1321,
"preview": "#region License Apache 2.0\n/* Copyright 2019-2021, 2024 Octonica\n *\n * Licensed under the Apache License, Version 2.0 ("
},
{
"path": "src/Octonica.ClickHouseClient/Types/FixedStringTableColumnBase.cs",
"chars": 3119,
"preview": "#region License Apache 2.0\n/* Copyright 2019-2021, 2024 Octonica\n *\n * Licensed under the Apache License, Version 2.0 ("
},
{
"path": "src/Octonica.ClickHouseClient/Types/FixedStringTypeInfo.cs",
"chars": 19174,
"preview": "#region License Apache 2.0\n/* Copyright 2019-2021, 2023 Octonica\n *\n * Licensed under the Apache License, Version 2.0 ("
},
{
"path": "src/Octonica.ClickHouseClient/Types/Float32TableColumn.cs",
"chars": 1401,
"preview": "#region License Apache 2.0\n/* Copyright 2019-2020 Octonica\n *\n * Licensed under the Apache License, Version 2.0 (the \"L"
},
{
"path": "src/Octonica.ClickHouseClient/Types/Float32TypeInfo.cs",
"chars": 4011,
"preview": "#region License Apache 2.0\n/* Copyright 2019-2021, 2023 Octonica\n *\n * Licensed under the Apache License, Version 2.0 ("
},
{
"path": "src/Octonica.ClickHouseClient/Types/Float64TypeInfo.cs",
"chars": 4189,
"preview": "#region License Apache 2.0\n/* Copyright 2019-2021, 2023 Octonica\n *\n * Licensed under the Apache License, Version 2.0 ("
},
{
"path": "src/Octonica.ClickHouseClient/Types/HexStringLiteralValueWriter.cs",
"chars": 3320,
"preview": "#region License Apache 2.0\n/* Copyright 2023 Octonica\n *\n * Licensed under the Apache License, Version 2.0 (the \"Licens"
},
{
"path": "src/Octonica.ClickHouseClient/Types/HexStringLiteralWriterCastMode.cs",
"chars": 792,
"preview": "#region License Apache 2.0\n/* Copyright 2023 Octonica\n *\n * Licensed under the Apache License, Version 2.0 (the \"Licens"
},
{
"path": "src/Octonica.ClickHouseClient/Types/HexStringParameterWriter.cs",
"chars": 8382,
"preview": "#region License Apache 2.0\n/* Copyright 2023 Octonica\n *\n * Licensed under the Apache License, Version 2.0 (the \"Licens"
},
{
"path": "src/Octonica.ClickHouseClient/Types/IClickHouseColumnReinterpreter.cs",
"chars": 952,
"preview": "#region License Apache 2.0\r\n/* Copyright 2024 Octonica\r\n *\r\n * Licensed under the Apache License, Version 2.0 (the \"Lic"
},
{
"path": "src/Octonica.ClickHouseClient/Types/IClickHouseColumnTypeDescriptor.cs",
"chars": 2136,
"preview": "#region License Apache 2.0\n/* Copyright 2021-2022 Octonica\n *\n * Licensed under the Apache License, Version 2.0 (the \"L"
},
{
"path": "src/Octonica.ClickHouseClient/Types/IClickHouseColumnTypeInfo.cs",
"chars": 7114,
"preview": "#region License Apache 2.0\n/* Copyright 2020-2021, 2023-2024 Octonica\n *\n * Licensed under the Apache License, Version "
},
{
"path": "src/Octonica.ClickHouseClient/Types/IClickHouseConfigurableTypeInfo.cs",
"chars": 1437,
"preview": "#region License Apache 2.0\n/* Copyright 2019-2021 Octonica\n *\n * Licensed under the Apache License, Version 2.0 (the \"L"
},
{
"path": "src/Octonica.ClickHouseClient/Types/IClickHouseEnumConverter.cs",
"chars": 3748,
"preview": "#region License Apache 2.0\n/* Copyright 2020-2021 Octonica\n *\n * Licensed under the Apache License, Version 2.0 (the \"L"
},
{
"path": "src/Octonica.ClickHouseClient/Types/IClickHouseReinterpretedTableColumn.cs",
"chars": 916,
"preview": "#region License Apache 2.0\r\n/* Copyright 2024 Octonica\r\n *\r\n * Licensed under the Apache License, Version 2.0 (the \"Lic"
},
{
"path": "src/Octonica.ClickHouseClient/Types/IClickHouseTypeInfo.cs",
"chars": 3324,
"preview": "#region License Apache 2.0\n/* Copyright 2019-2021 Octonica\n *\n * Licensed under the Apache License, Version 2.0 (the \"L"
},
{
"path": "src/Octonica.ClickHouseClient/Types/IClickHouseTypeInfoProvider.cs",
"chars": 2251,
"preview": "#region License Apache 2.0\n/* Copyright 2019-2022 Octonica\n *\n * Licensed under the Apache License, Version 2.0 (the \"L"
},
{
"path": "src/Octonica.ClickHouseClient/Types/Int128TypeInfo.cs",
"chars": 964,
"preview": "#region License Apache 2.0\n/* Copyright 2021 Octonica\n *\n * Licensed under the Apache License, Version 2.0 (the \"Licens"
},
{
"path": "src/Octonica.ClickHouseClient/Types/Int16TableColumn.cs",
"chars": 1747,
"preview": "#region License Apache 2.0\n/* Copyright 2019-2020 Octonica\n *\n * Licensed under the Apache License, Version 2.0 (the \"L"
},
{
"path": "src/Octonica.ClickHouseClient/Types/Int16TypeInfo.cs",
"chars": 4651,
"preview": "#region License Apache 2.0\n/* Copyright 2019-2021, 2023 Octonica\n *\n * Licensed under the Apache License, Version 2.0 ("
},
{
"path": "src/Octonica.ClickHouseClient/Types/Int256TypeInfo.cs",
"chars": 964,
"preview": "#region License Apache 2.0\n/* Copyright 2021 Octonica\n *\n * Licensed under the Apache License, Version 2.0 (the \"Licens"
},
{
"path": "src/Octonica.ClickHouseClient/Types/Int32TableColumn.cs",
"chars": 1379,
"preview": "#region License Apache 2.0\n/* Copyright 2019-2020 Octonica\n *\n * Licensed under the Apache License, Version 2.0 (the \"L"
},
{
"path": "src/Octonica.ClickHouseClient/Types/Int32TypeInfo.cs",
"chars": 5070,
"preview": "#region License Apache 2.0\n/* Copyright 2019-2021, 2023 Octonica\n *\n * Licensed under the Apache License, Version 2.0 ("
},
{
"path": "src/Octonica.ClickHouseClient/Types/Int64TypeInfo.cs",
"chars": 5289,
"preview": "#region License Apache 2.0\n/* Copyright 2019-2021, 2023 Octonica\n *\n * Licensed under the Apache License, Version 2.0 ("
},
{
"path": "src/Octonica.ClickHouseClient/Types/Int8TableColumn.cs",
"chars": 2114,
"preview": "#region License Apache 2.0\n/* Copyright 2019-2020 Octonica\n *\n * Licensed under the Apache License, Version 2.0 (the \"L"
},
{
"path": "src/Octonica.ClickHouseClient/Types/Int8TypeInfo.cs",
"chars": 4193,
"preview": "#region License Apache 2.0\n/* Copyright 2019-2021, 2023 Octonica\n *\n * Licensed under the Apache License, Version 2.0 ("
},
{
"path": "src/Octonica.ClickHouseClient/Types/IntermediateClickHouseTypeInfo.cs",
"chars": 1208,
"preview": "#region License Apache 2.0\n/* Copyright 2021 Octonica\n *\n * Licensed under the Apache License, Version 2.0 (the \"Licens"
},
{
"path": "src/Octonica.ClickHouseClient/Types/IpColumnReaderBase.cs",
"chars": 2319,
"preview": "#region License Apache 2.0\n/* Copyright 2020-2021 Octonica\n *\n * Licensed under the Apache License, Version 2.0 (the \"L"
},
{
"path": "src/Octonica.ClickHouseClient/Types/IpV4TableColumn.cs",
"chars": 4775,
"preview": "#region License Apache 2.0\n/* Copyright 2020-2021, 2024 Octonica\n *\n * Licensed under the Apache License, Version 2.0 ("
},
{
"path": "src/Octonica.ClickHouseClient/Types/IpV4TypeInfo.cs",
"chars": 6244,
"preview": "#region License Apache 2.0\n/* Copyright 2020-2021, 2023 Octonica\n *\n * Licensed under the Apache License, Version 2.0 ("
},
{
"path": "src/Octonica.ClickHouseClient/Types/IpV6TableColumn.cs",
"chars": 1962,
"preview": "#region License Apache 2.0\n/* Copyright 2020-2021, 2024 Octonica\n *\n * Licensed under the Apache License, Version 2.0 ("
},
{
"path": "src/Octonica.ClickHouseClient/Types/IpV6TypeInfo.cs",
"chars": 6618,
"preview": "#region License Apache 2.0\n/* Copyright 2020-2021, 2023-2024 Octonica\n *\n * Licensed under the Apache License, Version "
},
{
"path": "src/Octonica.ClickHouseClient/Types/KeyValuePairTableColumn.cs",
"chars": 2780,
"preview": "#region License Apache 2.0\n/* Copyright 2021, 2024 Octonica\n *\n * Licensed under the Apache License, Version 2.0 (the \""
},
{
"path": "src/Octonica.ClickHouseClient/Types/LowCardinalityTableColumn.cs",
"chars": 9447,
"preview": "#region License Apache 2.0\n/* Copyright 2020-2021, 2024 Octonica\n *\n * Licensed under the Apache License, Version 2.0 ("
},
{
"path": "src/Octonica.ClickHouseClient/Types/LowCardinalityTypeInfo.cs",
"chars": 25486,
"preview": "#region License Apache 2.0\n/* Copyright 2020-2021, 2023-2024 Octonica\n *\n * Licensed under the Apache License, Version "
},
{
"path": "src/Octonica.ClickHouseClient/Types/MapTypeInfo.cs",
"chars": 16581,
"preview": "#region License Apache 2.0\n/* Copyright 2021, 2023-2024 Octonica\n *\n * Licensed under the Apache License, Version 2.0 ("
},
{
"path": "src/Octonica.ClickHouseClient/Types/NothingTableColumn.cs",
"chars": 1707,
"preview": "#region License Apache 2.0\n/* Copyright 2019-2021 Octonica\n *\n * Licensed under the Apache License, Version 2.0 (the \"L"
},
{
"path": "src/Octonica.ClickHouseClient/Types/NothingTypeInfo.cs",
"chars": 6689,
"preview": "#region License Apache 2.0\n/* Copyright 2019-2021, 2023-2024 Octonica\n *\n * Licensed under the Apache License, Version "
},
{
"path": "src/Octonica.ClickHouseClient/Types/NullableTableColumn.cs",
"chars": 16291,
"preview": "#region License Apache 2.0\n/* Copyright 2019-2021, 2024 Octonica\n *\n * Licensed under the Apache License, Version 2.0 ("
},
{
"path": "src/Octonica.ClickHouseClient/Types/NullableTypeInfo.cs",
"chars": 21013,
"preview": "#region License Apache 2.0\n/* Copyright 2019-2021, 2023-2024 Octonica\n *\n * Licensed under the Apache License, Version "
},
{
"path": "src/Octonica.ClickHouseClient/Types/ObjectColumnAdapter.cs",
"chars": 2106,
"preview": "#region License Apache 2.0\n/* Copyright 2019-2021, 2024 Octonica\n *\n * Licensed under the Apache License, Version 2.0 ("
},
{
"path": "src/Octonica.ClickHouseClient/Types/ReinterpretedArrayTableColumn.cs",
"chars": 2356,
"preview": "#region License Apache 2.0\n/* Copyright 2021 Octonica\n *\n * Licensed under the Apache License, Version 2.0 (the \"Licens"
},
{
"path": "src/Octonica.ClickHouseClient/Types/ReinterpretedObjectTableColumn.cs",
"chars": 3028,
"preview": "#region License Apache 2.0\r\n/* Copyright 2024 Octonica\r\n *\r\n * Licensed under the Apache License, Version 2.0 (the \"Lic"
},
{
"path": "src/Octonica.ClickHouseClient/Types/ReinterpretedTableColumn.cs",
"chars": 8556,
"preview": "#region License Apache 2.0\n/* Copyright 2019-2021, 2024 Octonica\n *\n * Licensed under the Apache License, Version 2.0 ("
},
{
"path": "src/Octonica.ClickHouseClient/Types/SimpleLiteralValueWriter.cs",
"chars": 1222,
"preview": "#region License Apache 2.0\n/* Copyright 2023 Octonica\n *\n * Licensed under the Apache License, Version 2.0 (the \"Licens"
},
{
"path": "src/Octonica.ClickHouseClient/Types/SimpleParameterWriter.cs",
"chars": 6084,
"preview": "#region License Apache 2.0\n/* Copyright 2023 Octonica\n *\n * Licensed under the Apache License, Version 2.0 (the \"Licens"
},
{
"path": "src/Octonica.ClickHouseClient/Types/SimpleSkippingColumnReader.cs",
"chars": 1713,
"preview": "#region License Apache 2.0\n/* Copyright 2021 Octonica\n *\n * Licensed under the Apache License, Version 2.0 (the \"Licens"
},
{
"path": "src/Octonica.ClickHouseClient/Types/SimpleTypeInfo.cs",
"chars": 3223,
"preview": "#region License Apache 2.0\n/* Copyright 2019-2021, 2023 Octonica\n *\n * Licensed under the Apache License, Version 2.0 ("
},
{
"path": "src/Octonica.ClickHouseClient/Types/SparseColumn.cs",
"chars": 4818,
"preview": "#region License Apache 2.0\r\n/* Copyright 2024 Octonica\r\n *\r\n * Licensed under the Apache License, Version 2.0 (the \"Lic"
},
{
"path": "src/Octonica.ClickHouseClient/Types/StringByteArrayTableColumn.cs",
"chars": 1418,
"preview": "#region License Apache 2.0\n/* Copyright 2021, 2024 Octonica\n *\n * Licensed under the Apache License, Version 2.0 (the \""
},
{
"path": "src/Octonica.ClickHouseClient/Types/StringCharArrayTableColumn.cs",
"chars": 1585,
"preview": "#region License Apache 2.0\n/* Copyright 2021, 2024 Octonica\n *\n * Licensed under the Apache License, Version 2.0 (the \""
},
{
"path": "src/Octonica.ClickHouseClient/Types/StringLiteralValueWriter.cs",
"chars": 3779,
"preview": "#region License Apache 2.0\n/* Copyright 2023 Octonica\n *\n * Licensed under the Apache License, Version 2.0 (the \"Licens"
},
{
"path": "src/Octonica.ClickHouseClient/Types/StringParameterWriter.cs",
"chars": 4525,
"preview": "#region License Apache 2.0\n/* Copyright 2023 Octonica\n *\n * Licensed under the Apache License, Version 2.0 (the \"Licens"
},
{
"path": "src/Octonica.ClickHouseClient/Types/StringTableColumn.cs",
"chars": 1328,
"preview": "#region License Apache 2.0\n/* Copyright 2019-2021, 2024 Octonica\n *\n * Licensed under the Apache License, Version 2.0 ("
},
{
"path": "src/Octonica.ClickHouseClient/Types/StringTableColumnBase.cs",
"chars": 3711,
"preview": "#region License Apache 2.0\n/* Copyright 2019-2021, 2024 Octonica\n *\n * Licensed under the Apache License, Version 2.0 ("
},
{
"path": "src/Octonica.ClickHouseClient/Types/StringTypeInfo.cs",
"chars": 14805,
"preview": "#region License Apache 2.0\n/* Copyright 2019-2021, 2023 Octonica\n *\n * Licensed under the Apache License, Version 2.0 ("
},
{
"path": "src/Octonica.ClickHouseClient/Types/StructureReaderBase.cs",
"chars": 7230,
"preview": "#region License Apache 2.0\n/* Copyright 2019-2021 Octonica\n *\n * Licensed under the Apache License, Version 2.0 (the \"L"
},
{
"path": "src/Octonica.ClickHouseClient/Types/StructureTableColumn.cs",
"chars": 1864,
"preview": "#region License Apache 2.0\n/* Copyright 2019-2021, 2024 Octonica\n *\n * Licensed under the Apache License, Version 2.0 ("
},
{
"path": "src/Octonica.ClickHouseClient/Types/StructureWriterBase.cs",
"chars": 6350,
"preview": "#region License Apache 2.0\n/* Copyright 2019-2021 Octonica\n *\n * Licensed under the Apache License, Version 2.0 (the \"L"
},
{
"path": "src/Octonica.ClickHouseClient/Types/TupleTableColumn.cs",
"chars": 57145,
"preview": "#region License Apache 2.0\n/* Copyright 2019-2021, 2024 Octonica\n *\n * Licensed under the Apache License, Version 2.0 ("
},
{
"path": "src/Octonica.ClickHouseClient/Types/TupleTypeInfo.cs",
"chars": 69791,
"preview": "#region License Apache 2.0\n/* Copyright 2019-2021, 2023-2024 Octonica\n *\n * Licensed under the Apache License, Version "
},
{
"path": "src/Octonica.ClickHouseClient/Types/UInt128TypeInfo.cs",
"chars": 968,
"preview": "#region License Apache 2.0\n/* Copyright 2021 Octonica\n *\n * Licensed under the Apache License, Version 2.0 (the \"Licens"
},
{
"path": "src/Octonica.ClickHouseClient/Types/UInt16TableColumn.cs",
"chars": 2492,
"preview": "#region License Apache 2.0\n/* Copyright 2019-2020 Octonica\n *\n * Licensed under the Apache License, Version 2.0 (the \"L"
},
{
"path": "src/Octonica.ClickHouseClient/Types/UInt16TypeInfo.cs",
"chars": 4495,
"preview": "#region License Apache 2.0\n/* Copyright 2019-2021, 2023 Octonica\n *\n * Licensed under the Apache License, Version 2.0 ("
},
{
"path": "src/Octonica.ClickHouseClient/Types/UInt256TypeInfo.cs",
"chars": 968,
"preview": "#region License Apache 2.0\n/* Copyright 2021 Octonica\n *\n * Licensed under the Apache License, Version 2.0 (the \"Licens"
},
{
"path": "src/Octonica.ClickHouseClient/Types/UInt32TableColumn.cs",
"chars": 1753,
"preview": "#region License Apache 2.0\n/* Copyright 2019-2020 Octonica\n *\n * Licensed under the Apache License, Version 2.0 (the \"L"
},
{
"path": "src/Octonica.ClickHouseClient/Types/UInt32TypeInfo.cs",
"chars": 4666,
"preview": "#region License Apache 2.0\n/* Copyright 2019-2021, 2023 Octonica\n *\n * Licensed under the Apache License, Version 2.0 ("
},
{
"path": "src/Octonica.ClickHouseClient/Types/UInt64TypeInfo.cs",
"chars": 4841,
"preview": "#region License Apache 2.0\n/* Copyright 2019-2021, 2023 Octonica\n *\n * Licensed under the Apache License, Version 2.0 ("
}
]
// ... and 65 more files (download for full content)
About this extraction
This page contains the full source code of the Octonica/ClickHouseClient GitHub repository, extracted and formatted as plain text for AI agents and large language models (LLMs). The extraction includes 265 files (1.9 MB), approximately 446.1k tokens, and a symbol index with 2612 extracted functions, classes, methods, constants, and types. Use this with OpenClaw, Claude, ChatGPT, Cursor, Windsurf, or any other AI tool that accepts text input. You can copy the full output to your clipboard or download it as a .txt file.
Extracted by GitExtract — free GitHub repo to text converter for AI. Built by Nikandr Surkov.