package bloom

Import Path
	github.com/parquet-go/parquet-go/bloom (on go.dev)

Dependency Relation
	imports 6 packages, and imported by one package


Involved Source Files

	    block.go
	    block_amd64.go
	
		Package bloom implements parquet bloom filters.

	    filter.go
	    filter_amd64.go
	    hash.go
	    block_amd64.s
	    filter_amd64.s


Package-Level Type Names (total 6)


	/* sort by:  |  */
	
		Block represents bloom filter blocks which contain eight 32 bits words.

		
			
				Bytes returns b as a byte slice.

			(*Block) Check(x uint32) bool
			(*Block) Insert(x uint32)
		
			*Block : github.com/apache/arrow-go/v18/internal/hashing.ByteSlice
		
			func SplitBlockFilter.Block(x uint64) *Block


	
		Filter is an interface representing read-only bloom filters where programs
		can probe for the possible presence of a hash key.

		
			( Filter) Check(uint64) bool
		
			 SplitBlockFilter


	
		Hash is an interface abstracting the hashing algorithm used in bloom filters.
		
		Hash instances must be safe to use concurrently from multiple goroutines.

		
			( Hash) MultiSum64Uint128(dst []uint64, src [][16]byte) int
			( Hash) MultiSum64Uint16(dst []uint64, src []uint16) int
			( Hash) MultiSum64Uint32(dst []uint64, src []uint32) int
			( Hash) MultiSum64Uint64(dst []uint64, src []uint64) int
			
				Compute hashes of the array of fixed size values passed as arguments,
				returning the number of hashes written to the destination buffer.

			
				Returns the 64 bit hash of the value passed as argument.

			( Hash) Sum64Uint128(value [16]byte) uint64
			( Hash) Sum64Uint16(value uint16) uint64
			( Hash) Sum64Uint32(value uint32) uint64
			( Hash) Sum64Uint64(value uint64) uint64
			
				Compute hashes of individual values of primitive types.

		
			 XXH64
		
			func github.com/parquet-go/parquet-go.BloomFilterColumn.Hash() Hash


	
		SplitBlockFilter is an in-memory implementation of the parquet bloom filters.
		
		This type is useful to construct bloom filters that are later serialized
		to a storage medium.

		
			
				Block returns a pointer to the block that the given value hashes to in the
				bloom filter.

			
				Bytes converts f to a byte slice.
				
				The returned slice shares the memory of f. The method is intended to be used
				to serialize the bloom filter to a storage medium.

			
				Check tests whether x is in f.

			
				Insert adds x to f.

			
				InsertBulk adds all values from x into f.

			
				Reset clears the content of the filter f.

		
			 SplitBlockFilter : Filter
			 SplitBlockFilter : github.com/apache/arrow-go/v18/internal/hashing.ByteSlice
		
			func MakeSplitBlockFilter(data []byte) SplitBlockFilter


	
		Word represents 32 bits words of bloom filter blocks.


	
		XXH64 is an implementation of the Hash interface using the XXH64 algorithm.

		
			( XXH64) MultiSum64Uint128(h []uint64, v [][16]byte) int
			( XXH64) MultiSum64Uint16(h []uint64, v []uint16) int
			( XXH64) MultiSum64Uint32(h []uint64, v []uint32) int
			( XXH64) MultiSum64Uint64(h []uint64, v []uint64) int
			( XXH64) MultiSum64Uint8(h []uint64, v []uint8) int
			( XXH64) Sum64(b []byte) uint64
			( XXH64) Sum64Uint128(v [16]byte) uint64
			( XXH64) Sum64Uint16(v uint16) uint64
			( XXH64) Sum64Uint32(v uint32) uint64
			( XXH64) Sum64Uint64(v uint64) uint64
			( XXH64) Sum64Uint8(v uint8) uint64
		
			 XXH64 : Hash




Package-Level Functions (total 3)


	
		CheckSplitBlock is similar to bloom.SplitBlockFilter.Check but reads the
		bloom filter of n bytes from r.
		
		The size n of the bloom filter is assumed to be a multiple of the block size.


	
		MakeSplitBlockFilter constructs a SplitBlockFilter value from the data byte
		slice.


	
		NumSplitBlocksOf returns the number of blocks in a filter intended to hold
		the given number of values and bits of filter per value.
		
		This function is useful to determine the number of blocks when creating bloom
		filters in memory, for example:
		
			f := make(bloom.SplitBlockFilter, bloom.NumSplitBlocksOf(n, 10))




Package-Level Constants (only one)


	
		BlockSize is the size of bloom filter blocks in bytes.