Class Filter (5.0.0)

Package

Constructors

(constructor)()

constructor();

Properties

filters_

filters_: Array<{
        [index: string]: {};
    }>;

Methods

all(pass)

all(pass: boolean): void;

//-
// Matches all cells, regardless of input. Functionally equivalent to
// leaving `filter` unset, but included for completeness.
//-
const filter = {
  all: true
};

//-
// Does not match any cells, regardless of input. Useful for temporarily
// disabling just part of a filter.
//-
const filter = {
  all: false
};

column(column)

column(column: RegExp | string | {}): void;

//-
// Using the following filter, we would retrieve the `tjefferson` and
// `gwashington` columns.
//-
const filter = [
  {
    column: /[a-z]+on$/
  }
];

//-
// You can also provide a string (optionally containing regexp characters)
// for simple column filters.
//-
const filter = [
  {
    column: 'gwashington'
  }
];

//-
// Or you can provide an array of strings if you wish to match against
// multiple columns.
//-
const filter = [
  {
    column: [
      'gwashington',
      'tjefferson'
    ]
  }
];

//-
// If you wish to use additional column filters, consider using the following
// syntax.
//-
const filter = [
  {
    column: {
      name: 'gwashington'
    }
  }
];


//-
// 
Column Cell Limits
//
// Matches only the most recent number of versions within each column. For
// example, if the `versions` is set to 2, this filter would only match
// columns updated at the two most recent timestamps.
//
// If duplicate cells are present, as is possible when using an
// {@link Filter#interleave} filter, each copy of the cell is
// counted separately.
//-
const filter = [
  {
    column: {
      cellLimit: 2
    }
  }
];

//-
// 
Column Ranges
//
// Specifies a contiguous range of columns within a single column family.
// The range spans from 

condition(condition)

condition(condition: Condition): void;

//-
// In the following example we're creating a filter that will check if
// `gwashington` follows `tjefferson`. If he does, we'll get all of the
// `gwashington` data. If he does not, we'll instead return all of the
// `tjefferson` data.
//-
const filter = [
  {
    condition: {
      // If `test` outputs any cells, then `pass` will be evaluated on the
      // input row. Otherwise `fail` will be evaluated.
      test: [
        {
          row: 'gwashington'
        },
        {
          family: 'follows'
        },
        {
          column: 'tjefferson'
        }
      ],

      // If omitted, no results will be returned in the true case.
      pass: [
        {
          row: 'gwashington'
        }
      ],

      // If omitted, no results will be returned in the false case.
      fail: [
        {
          row: 'tjefferson'
        }
      ]
    }
  }
];

convertToRegExpString(regex)

static convertToRegExpString(regex: RegExp | RegExp[] | string | string[] | Buffer | Buffer[] | number | number[]): string | Buffer;

const regexString = Filter.convertToRegExpString(['a', 'b', 'c']);
// => '(a|b|c)'

createRange(start, end, key)

static createRange(start: BoundData | null, end: BoundData | null, key: string): {};

const {Bigtable} = require('@google-cloud/bigtable');
const Filter = Bigtable.Filter;

const range = Filter.createRange('value1', 'value2', 'Test');
// {
//   startTestInclusive: new Buffer('value1'),
//   endTestExclusive: new Buffer('value2')
// }

//-
// It's also possible to pass in objects to specify inclusive/exclusive
// bounds.
//-
const upperBound = {
  value: 'value3',
  inclusive: false
};

const range = Filter.createRange(upperBound, null, 'Test2');
// => {
//   startTest2Exclusive: 'value3'
// }

family(family)

family(family: RegExp | string | number | Buffer | RegExp[] | string[] | number[] | Buffer[]): void;

const filter = [
  {
    family: 'follows'
  }
];

interleave(filters)

interleave(filters: RawFilter[]): void;

//-
// In the following example, we're creating a filter that will retrieve
// results for entries that were either created between December 17th, 2015
// and March 22nd, 2016 or entries that have data for `follows:tjefferson`.
//-
const filter = [
  {
    interleave: [
      [
        {
          time: {
            start: new Date('December 17, 2015'),
            end: new Date('March 22, 2016')
          }
        }
      ],
      [
        {
          family: 'follows'
        },
        {
          column: 'tjefferson'
        }
      ]
    ]
  }
];

label(label)

label(label: string): void;

const filter = {
  label: 'my-label'
};

parse(filters)

static parse(filters: RawFilter[] | RawFilter): {} | null;

const filter = Filter.parse([
  {
    family: 'my-family',
  }, {
    column: 'my-column'
  }
]);
// {
//   chain: {
//     filters: [
//       {
//         familyNameRegexFilter: 'my-family'
//       },
//       {
//         columnQualifierRegexFilter: 'my-column'
//       }
//     ]
//   }
// }

row(row)

row(row: Row | string | RegExp | string[]): void;

//-
// In the following example we'll use a regular expression to match all
// row keys ending with the letters "on", which would then yield
// `gwashington` and `tjefferson`.
//-
const filter = [
  {
    row: /[a-z]+on$/
  }
];

//-
// You can also provide a string (optionally containing regexp characters)
// for simple key filters.
//-
const filter = [
  {
    row: 'gwashington'
  }
];

//-
// Or you can provide an array of strings if you wish to match against
// multiple keys.
//-
const filter = [
  {
    row: [
      'gwashington',
      'tjefferson'
    ]
  }
];

//-
// If you wish to use additional row filters, consider using the following
// syntax.
//-
const filter = [
  {
    row: {
      key: 'gwashington'
    }
  }
];

//-
// 
Row Samples
//
// Matches all cells from a row with probability p, and matches no cells
// from the row with probability 1-p.
//-
const filter = [
  {
    row: {
      sample: 1
    }
  }
];

//-
// 
Row Cell Offsets
//
// Skips the first N cells of each row, matching all subsequent cells.
// If duplicate cells are present, as is possible when using an
// {@link Filter#interleave}, each copy of the cell is counted
// separately.
//-
const filter = [
  {
    row: {
      cellOffset: 2
    }
  }
];

//-
// 
Row Cell Limits
//
// Matches only the first N cells of each row.
// If duplicate cells are present, as is possible when using an
// {@link Filter#interleave}, each copy of the cell is counted
// separately.
//-
const filter = [
  {
    row: {
      cellLimit: 4
    }
  }
];

set(key, value)

set(key: string, value: {}): void;

sink(sink)

sink(sink: boolean): void;

//-
// Using the following filter, a copy of every cell that reaches the sink is
// present in the final result, despite being excluded by the qualifier
// filter
//-
const filter = [
  {
    family: 'follows'
  },
  {
    interleave: [
      [
        {
          all: true
        }
      ],
      [
        {
          label: 'prezzy'
        },
        {
          sink: true
        }
      ]
    ]
  },
  {
    column: 'gwashington'
  }
];

//-
// As with an {@link Filter#interleave} filter, duplicate cells
// are possible, and appear in an unspecified mutual order. In this case we
// have a duplicates with multiple `gwashington` columns because one copy
// passed through the {@link Filter#all} filter while the other was
// passed through the {@link Filter#label} and sink. Note that one
// copy has label "prezzy" while the other does not.
//-

time(time)

time(time: Time): void;

const filter = [
  {
    time: {
      start: new Date('December 17, 2006 03:24:00'),
      end: new Date()
    }
  }
];

toProto()

toProto(): null | {};

value(value)

value(value: string | string[] | ValueFilter): void;

const filter = [
  {
    value: /[0-9]/
  }
];

//-
// You can also provide a string (optionally containing regexp characters)
// for value filters.
//-
const filter = [
  {
    value: '1'
  }
];

//-
// You can also provide an array of strings if you wish to match against
// multiple values.
//-
const filter = [
  {
    value: ['1', '9']
  }
];

//-
// Or you can provide a Buffer or an array of Buffers if you wish to match
// against specfic binary value(s).
//-
const userInputedFaces = [Buffer.from('.|.'), Buffer.from(':-)')];
const filter = [
  {
    value: userInputedFaces
  }
];

//-
// 
Value Ranges
//
// Specifies a contiguous range of values.
//
// When the `start` bound is omitted it is interpreted as an empty string.
// When the `end` bound is omitted it is interpreted as Infinity.
//-
const filter = [
  {
    value: {
      start: '1',
      end: '9'
    }
  }
];

//-
// By default, both the `start` and `end` bounds are inclusive. You can
// override these by providing an object explicity stating whether or not it
// is `inclusive`.
//-
const filter = [
  {
    value: {
      start: {
        value: '1',
        inclusive: false
      },
      end: {
        value: '9',
        inclusive: false
      }
    }
  }
];

//-
// 
Strip Values
//
// Replaces each cell's value with an emtpy string.
//-
const filter = [
  {
    value: {
      strip: true
    }
  }
];