List records of a Tulip Table

The format that Tulip should use in the response when formatting Tulip numbers. If omitted or set to float, Tulip will format numbers as JSON numbers. If set to decimal, Tulip will format numbers as strings representing the decimal representation of the number, like "1.20". Tulip will only output trailing zeros when using decimal formatting.

Filtering

Tulip interprets JSON numbers as floating-point values, which may result in edge cases when this header's value is decimal. If you set this header to decimal, we recommend passing values for Tulip number fields as strings.

Specifically, if this header is set to decimal and filters specifies a Tulip number field, that filter's arg will be interpreted as a decimal value. If it's passed in as a string, it must be of format "[-]xx[.yyy]". If it's passed in as a JSON number, it will be parsed as a JavaScript number, and then converted to a decimal string. This may result in loss of precision, since JavaScript numbers have limited precision (roughly 15-17 digits).

For example, the number 2.0000000000000002 cannot be expressed as a JavaScript number, so it will be parsed as 2. This means that if you are trying to look up a value with {... "functionType", "equal", "arg", 2.0000000000000002}, Tulip will not find that value (since it will instead look for values that equal 2). To specify filters for such numbers when this header is decimal, we recommend you pass them in as strings, like "2.0000000000000002".

Sorting

If this header is set to decimal and sortOptions specifies a Tulip number field, that field will be ordered by value (as normal) and then by number of trailing zeros, with fewer zeros sorting earlier. For example, 1.2 will sort before 1.20. If the header is unset or set to float, trailing zeros will not be taken into consideration when sorting. This discrepancy in the handling of trailing zeros can result in inconsistent ordering if sortOptions specifies multiple fields. For example, with records:

Sorting by myNumber, Id with this header set to decimal will result in:

[
  {"myNumber": "1.2", "Id": "B"},
  {"myNumber": "1.20", "Id": "A"}
]

... because "1.20" sorts before "1.2". On the other hand, without this header, the result will be:

[
  {"myNumber": 1.2, "Id": "A"},
  {"myNumber": 1.2, "Id": "B"}
]

... because the numbers are tied, so the secondary sorting on Id factors in.

Note that this header only affects Tulip numbers. Other types, including Tulip integers, are unaffected.

The id of a Tulip Table.

A limit for how many records should be returned in the response. At most this many records will be returned. To determine if there are more records beyond those included in the response, use the includeTotalCount query parameter. Defaults to 10 records and cannot be more than 100 records.

The index of the record to start at. The exact order of returned records depends on the sortBy and sortDir parameters. This parameter is usually used for pagination.

If this flag is set, the total number of records in the Table which match the filters is returned in the X-Total-Count header in the response. Determining this count requires an extra (potentially expensive) database query, so clients should omit this flag if the total count is not needed.

An optional array of filter expressions to filter the Table records by. Each filter is an object specifying the field (name of a table column), functionType (comparison function), and arg (the value to compare to).

The field may be the name of a table column (including id) or one of these special values:

• _createdAt
• _updatedAt

The valid function types are:

• equal
• notEqual
• blank
• notBlank
• greaterThanOrEqual
• lessThanOrEqual
• greaterThan
• lessThan
• contains
• notContains
• startsWith
• notStartsWith
• endsWith
• notEndsWith
• isIn
• notIsIn

Note: The isIn and notIsIn functions take in array inputs. To pass an array input into a connector function you must convert the array to a string of this format: ["1", "2", "3"]. Also, the blank and notBlank functions do not take in any arguments at all.

Example: [{"field": "field1", "functionType": "equal", "arg": "1"},{"field": "field2", "functionType": "notBlank"}, {"field": "field3", "functionType": "isIn", "arg": ["1", "2", "3"]}]

Specifiying fields allows to reduce the amount of data returned in the result to just the data for each of the fields specified. If ommitted, all fields for a given record will be returned. A field value that is not one of the table's fields will generate a 422 error.

Example: ["ipwkk_weight", "cyveu_completed", "id", "_updatedAt", "bDabBK8jmxZqWY8iT_link_left_column"]

How the filters in the filters parameter are combined.

• all means that every filter must match a record in order for the record to be included.
• any means at least one filter must match a record in order for the record to be included.

Sorting allows to define which records are considered if there are more than the specified limit. Sort priority is determined by the order or options, i.e. sort by the first option, them by the second, etc. If ommitted, there is no guarantee as to which records are selected. A sortBy value that is not one of the table's field will generate a 422 error. Options for sortDir are "asc" and "desc".

Example: [{"sortBy": "superAwesomeField", "sortDir": "asc"}, {"sortBy": "lessAwesomeField", "sortDir": "desc"}]