github.com/fraugster/parquet-go@v0.12.0/stats.go (about)

     1  package goparquet
     2  
     3  import (
     4  	"bytes"
     5  	"encoding/binary"
     6  	"math"
     7  )
     8  
     9  type nilStats struct{}
    10  
    11  func (s *nilStats) minValue() []byte {
    12  	return nil
    13  }
    14  
    15  func (s *nilStats) maxValue() []byte {
    16  	return nil
    17  }
    18  
    19  func (s *nilStats) reset() {
    20  }
    21  
    22  type statistics struct {
    23  	min []byte
    24  	max []byte
    25  }
    26  
    27  func (s *statistics) minValue() []byte {
    28  	return s.min
    29  }
    30  
    31  func (s *statistics) maxValue() []byte {
    32  	return s.max
    33  }
    34  
    35  func (s *statistics) reset() {
    36  	s.min, s.max = nil, nil
    37  }
    38  
    39  func (s *statistics) setMinMax(j []byte) {
    40  	if s.max == nil || s.min == nil {
    41  		s.min = j
    42  		s.max = j
    43  		return
    44  	}
    45  
    46  	if bytes.Compare(j, s.min) < 0 {
    47  		s.min = j
    48  	}
    49  	if bytes.Compare(j, s.max) > 0 {
    50  		s.max = j
    51  	}
    52  }
    53  
    54  type floatStats struct {
    55  	min float32
    56  	max float32
    57  }
    58  
    59  func newFloatStats() *floatStats {
    60  	s := &floatStats{}
    61  	s.reset()
    62  	return s
    63  }
    64  
    65  func (s *floatStats) reset() {
    66  	s.min = math.MaxFloat32
    67  	s.max = -math.MaxFloat32
    68  }
    69  
    70  func (s *floatStats) minValue() []byte {
    71  	if s.min == math.MaxFloat32 {
    72  		return nil
    73  	}
    74  	ret := make([]byte, 4)
    75  	binary.LittleEndian.PutUint32(ret, math.Float32bits(s.min))
    76  	return ret
    77  }
    78  
    79  func (s *floatStats) maxValue() []byte {
    80  	if s.max == -math.MaxFloat32 {
    81  		return nil
    82  	}
    83  	ret := make([]byte, 4)
    84  	binary.LittleEndian.PutUint32(ret, math.Float32bits(s.max))
    85  	return ret
    86  }
    87  
    88  func (s *floatStats) setMinMax(j float32) {
    89  	if j < s.min {
    90  		s.min = j
    91  	}
    92  	if j > s.max {
    93  		s.max = j
    94  	}
    95  }
    96  
    97  type doubleStats struct {
    98  	min float64
    99  	max float64
   100  }
   101  
   102  func newDoubleStats() *doubleStats {
   103  	s := &doubleStats{}
   104  	s.reset()
   105  	return s
   106  }
   107  
   108  func (s *doubleStats) reset() {
   109  	s.min = math.MaxFloat64
   110  	s.max = -math.MaxFloat64
   111  }
   112  
   113  func (s *doubleStats) minValue() []byte {
   114  	if s.min == math.MaxFloat64 {
   115  		return nil
   116  	}
   117  	ret := make([]byte, 8)
   118  	binary.LittleEndian.PutUint64(ret, math.Float64bits(s.min))
   119  	return ret
   120  }
   121  
   122  func (s *doubleStats) maxValue() []byte {
   123  	if s.max == -math.MaxFloat64 {
   124  		return nil
   125  	}
   126  	ret := make([]byte, 8)
   127  	binary.LittleEndian.PutUint64(ret, math.Float64bits(s.max))
   128  	return ret
   129  }
   130  
   131  func (s *doubleStats) setMinMax(j float64) {
   132  	if j < s.min {
   133  		s.min = j
   134  	}
   135  	if j > s.max {
   136  		s.max = j
   137  	}
   138  }
   139  
   140  type int32Stats struct {
   141  	min int32
   142  	max int32
   143  }
   144  
   145  func newInt32Stats() *int32Stats {
   146  	s := &int32Stats{}
   147  	s.reset()
   148  	return s
   149  }
   150  
   151  func (s *int32Stats) reset() {
   152  	s.min = math.MaxInt32
   153  	s.max = math.MinInt32
   154  }
   155  
   156  func (s *int32Stats) minValue() []byte {
   157  	if s.min == math.MaxInt32 {
   158  		return nil
   159  	}
   160  	ret := make([]byte, 4)
   161  	binary.LittleEndian.PutUint32(ret, uint32(s.min))
   162  	return ret
   163  }
   164  
   165  func (s *int32Stats) maxValue() []byte {
   166  	if s.max == math.MinInt32 {
   167  		return nil
   168  	}
   169  	ret := make([]byte, 4)
   170  	binary.LittleEndian.PutUint32(ret, uint32(s.max))
   171  	return ret
   172  }
   173  
   174  func (s *int32Stats) setMinMax(j int32) {
   175  	if j < s.min {
   176  		s.min = j
   177  	}
   178  	if j > s.max {
   179  		s.max = j
   180  	}
   181  }
   182  
   183  type int64Stats struct {
   184  	min int64
   185  	max int64
   186  }
   187  
   188  func newInt64Stats() *int64Stats {
   189  	s := &int64Stats{}
   190  	s.reset()
   191  	return s
   192  }
   193  
   194  func (s *int64Stats) reset() {
   195  	s.min = math.MaxInt64
   196  	s.max = math.MinInt64
   197  }
   198  
   199  func (s *int64Stats) minValue() []byte {
   200  	if s.min == math.MaxInt64 {
   201  		return nil
   202  	}
   203  	ret := make([]byte, 8)
   204  	binary.LittleEndian.PutUint64(ret, uint64(s.min))
   205  	return ret
   206  }
   207  
   208  func (s *int64Stats) maxValue() []byte {
   209  	if s.min == math.MinInt64 {
   210  		return nil
   211  	}
   212  	ret := make([]byte, 8)
   213  	binary.LittleEndian.PutUint64(ret, uint64(s.max))
   214  	return ret
   215  }
   216  
   217  func (s *int64Stats) setMinMax(j int64) {
   218  	if j < s.min {
   219  		s.min = j
   220  	}
   221  	if j > s.max {
   222  		s.max = j
   223  	}
   224  }