/// <inheritdoc /> public override long GetBytes(int ordinal, long fieldOffset, byte[] buffer, int bufferOffset, int length) { GaxPreconditions.CheckArgument(GetSpannerFieldType(ordinal).TypeCode == TypeCode.Bytes, nameof(ordinal), "Spanner only supports conversion to byte arrays for columns of type BYTES."); GaxPreconditions.CheckArgumentRange(bufferOffset, nameof(bufferOffset), 0, buffer?.Length ?? 0); GaxPreconditions.CheckArgumentRange(length, nameof(length), 0, buffer?.Length ?? int.MaxValue); if (buffer != null) { GaxPreconditions.CheckArgumentRange(bufferOffset + length, nameof(length), 0, buffer.Length); } var bytes = IsDBNull(ordinal) ? null : GetFieldValue <byte[]>(ordinal); if (buffer == null) { // Return the length of the value if `buffer` is null: // https://docs.microsoft.com/en-us/dotnet/api/system.data.idatarecord.getbytes?view=netstandard-2.1#remarks return(bytes?.Length ?? 0); } var copyLength = Math.Min(length, (bytes?.Length ?? 0) - (int)fieldOffset); if (copyLength < 0) { throw new ArgumentOutOfRangeException( nameof(fieldOffset), "Field offset exceeds the length of the field data"); } if (bytes != null) { Array.Copy(bytes, (int)fieldOffset, buffer, bufferOffset, copyLength); } return(copyLength); }
internal void Validate() { GaxPreconditions.CheckArgumentRange(StreamAckDeadline, nameof(StreamAckDeadline), MinimumStreamAckDeadline, MaximumStreamAckDeadline); var maxAckExtension = TimeSpan.FromTicks((StreamAckDeadline ?? DefaultStreamAckDeadline).Ticks / 2); GaxPreconditions.CheckArgumentRange(AckExtensionWindow, nameof(AckExtensionWindow), MinimumAckExtensionWindow, maxAckExtension); }
internal Timestamp(long seconds, int nanoseconds) { GaxPreconditions.CheckArgumentRange(seconds, nameof(seconds), MinSeconds, MaxSeconds); GaxPreconditions.CheckArgumentRange(nanoseconds, nameof(nanoseconds), 0, 999_999_999); _seconds = seconds; _nanoseconds = nanoseconds; }
// Note to readers: we should make it as easy as possible to do the work below, of course. // Possibly BigqueryClient should have a GetResultSet(jobReference, pageSize, pageToken) call. /// <summary> /// Eagerly fetches a set of rows, up to the specified count. /// </summary> /// <remarks> /// If <paramref name="maxRows"/> is smaller than the number of rows originally requested, /// this may require another server call to retrieve an appropriate page token. When working /// in pages, always specify a maximum per-request number of rows less than or equal to the /// page size you want. /// </remarks> /// <param name="maxRows">The maximum number of rows to retrieve. Must be positive.</param> /// <returns>An in-memory result set of at most the given number of rows.</returns> public BigqueryResultSet GetResultSet(int maxRows) { GaxPreconditions.CheckArgumentRange(maxRows, nameof(maxRows), 1, int.MaxValue); if (!Completed) { throw new InvalidOperationException($"Cannot call {nameof(GetResultSet)} on an incomplete job"); } GetQueryResultsOptions clonedOptions = _options?.Clone() ?? new GetQueryResultsOptions(); List <BigqueryRow> rows = new List <BigqueryRow>(maxRows); if ((clonedOptions.PageSize == null || clonedOptions.PageSize > maxRows) && _response.Rows?.Count > maxRows) { // Oops. Do it again from scratch, with a useful page size. clonedOptions.PageSize = maxRows; return(_client.GetQueryResults(JobReference, clonedOptions).GetResultSet(maxRows)); } // First add the rows from the first response which is part of the state // of the object. rows.AddRange(ResponseRows); string pageToken = _response.PageToken; clonedOptions.StartIndex = null; // Now keep going until we've filled the result set or know there's no more data. while (rows.Count > maxRows && pageToken != null) { clonedOptions.PageToken = pageToken; clonedOptions.PageSize = maxRows - rows.Count; var job = _client.GetQueryResults(JobReference, clonedOptions); rows.AddRange(job.ResponseRows); pageToken = job._response.PageToken; } return(new BigqueryResultSet(rows, Schema, JobReference, pageToken)); }
/// <summary> /// Specifies the maximum number of results to return. /// </summary> /// <remarks> /// This call replaces any previously-specified limit in the query. /// </remarks> /// <param name="limit">The maximum number of results to return. Must be greater than or equal to 0.</param> /// <returns>A new query based on the current one, but with the specified limit applied.</returns> public Query Limit(int limit) { GaxPreconditions.CheckArgumentRange(limit, nameof(limit), 0, int.MaxValue); var query = QueryProto.Clone(); query.Limit = limit; return(WithQuery(query)); }
/// <summary> /// Specifies a number of results to skip. /// </summary> /// <remarks> /// This call replaces any previously-specified offset in the query. /// </remarks> /// <param name="offset">The number of results to skip. Must be greater than or equal to 0.</param> /// <returns>A new query based on the current one, but with the specified offset applied.</returns> public Query Offset(int offset) { GaxPreconditions.CheckArgumentRange(offset, nameof(offset), 0, int.MaxValue); var query = QueryProto.Clone(); query.Offset = offset; return(WithQuery(query)); }
/// <summary> /// Eagerly fetches a set of rows, up to the specified count, providing a page of results with a next page token /// if more results are available. This is typically used within web applications, where the next page token /// is propagated to the client along with the results, so that the next page can be retrieved in another request. /// </summary> /// <param name="pageSize">The maximum number of rows to retrieve. Must be positive.</param> /// <returns>An in-memory result set of at most the given number of rows.</returns> public BigQueryPage ReadPage(int pageSize) { GaxPreconditions.CheckArgumentRange(pageSize, nameof(pageSize), 1, int.MaxValue); // Make sure we start off by trying to read the right page size... var options = GetOptionsWithPageSize(pageSize); var page = _client.ListRows(TableReference, Schema, options).ReadPage(pageSize); return(new BigQueryPage(page, Schema, JobReference, TableReference)); }
/// <summary> /// Asynchronously but eagerly fetches a set of rows, up to the specified count, providing a page of results with a next page token /// if more results are available. This is typically used within web applications, where the next page token /// is propagated to the client along with the results, so that the next page can be retrieved in another request. /// </summary> /// <param name="pageSize">The maximum number of rows to retrieve. Must be positive.</param> /// <param name="cancellationToken">The token to monitor for cancellation requests.</param> /// <returns>A task representing the asynchronous operation. When complete, the result is /// an in-memory result set of at most the given number of rows.</returns> public async Task <BigQueryPage> ReadPageAsync(int pageSize, CancellationToken cancellationToken = default(CancellationToken)) { GaxPreconditions.CheckArgumentRange(pageSize, nameof(pageSize), 1, int.MaxValue); // Make sure we start off by trying to read the right page size... var options = GetOptionsWithPageSize(pageSize); var page = await _client.ListRowsAsync(TableReference, Schema, options) .ReadPageAsync(pageSize, cancellationToken) .ConfigureAwait(false); return(new BigQueryPage(page, Schema, JobReference, TableReference)); }
internal void Validate() { if (BatchingSettings != null) { GaxPreconditions.CheckArgumentRange(BatchingSettings.ElementCountThreshold, $"{nameof(BatchingSettings)}.{nameof(BatchingSettings.ElementCountThreshold)}", 1, ApiMaxBatchingSettings.ElementCountThreshold.Value); GaxPreconditions.CheckArgumentRange(BatchingSettings.ByteCountThreshold, $"{nameof(BatchingSettings)}.{nameof(BatchingSettings.ByteCountThreshold)}", 1, ApiMaxBatchingSettings.ByteCountThreshold.Value); GaxPreconditions.CheckArgument((BatchingSettings.DelayThreshold ?? TimeSpan.FromSeconds(1)) > TimeSpan.Zero, $"{nameof(BatchingSettings)}.{nameof(BatchingSettings.DelayThreshold)}", "Must be positive"); } }
private BigtableVersion(long value, bool valueIsMillis) { if (valueIsMillis) { GaxPreconditions.CheckArgumentRange(value, nameof(value), -1, long.MaxValue / MillisPerMicro); _micros = value == -1 ? MicrosFromTimestamp(DateTime.UtcNow) : value * MillisPerMicro; } else { GaxPreconditions.CheckArgumentRange(value, nameof(value), -1, long.MaxValue); _micros = value; } }
internal RetryOptions(RetryType retryType, ExceptionHandling exceptionHandling, BufferOverflow bufferOverflow, int?bufferSizeBytes = null, int?retryAttempts = null, TimeSpan?retryInterval = null) { RetryType = GaxPreconditions.CheckEnumValue(retryType, nameof(retryType)); ExceptionHandling = GaxPreconditions.CheckEnumValue(exceptionHandling, nameof(exceptionHandling)); BufferOverflow = GaxPreconditions.CheckEnumValue(bufferOverflow, nameof(bufferOverflow)); BufferSizeBytes = GaxPreconditions.CheckArgumentRange( bufferSizeBytes ?? 0, nameof(bufferSizeBytes), 0, int.MaxValue); RetryAttempts = GaxPreconditions.CheckArgumentRange( retryAttempts ?? 0, nameof(retryAttempts), 0, int.MaxValue); RetryInterval = retryInterval ?? TimeSpan.Zero; GaxPreconditions.CheckArgument(RetryInterval >= TimeSpan.Zero, nameof(retryInterval), $"{nameof(retryInterval)} must be greater than 0"); }
/// <summary> /// Creates a new <see cref="BigtableVersion"/> value from the milliseconds of a timestamp since the Unix epoch. /// </summary> /// <remarks> /// <para> /// Note: version values are stored on the server as if they are microseconds since the Unix epoch. /// However, the server only supports millisecond granularity, so the server only allows microseconds /// in multiples of 1,000. <see cref="BigtableVersion"/> attempts to hide this complexity by exposing /// its underlying <see cref="Value"/> in terms of milliseconds, so if desired, a custom versioning /// scheme of 1, 2, ... can be used rather than 1000, 2000, ... However, access to the underlying /// microsecond value is still provided via <see cref="Micros"/>. /// </para> /// <para> /// Note: when using ReadModifyWriteRow, modified columns automatically use a server version, which /// is based on the current timestamp since the Unix epoch. For those columns, other reads and writes /// should use <see cref="BigtableVersion"/> values constructed from DateTime values, as opposed to /// using a custom versioning scheme with 64-bit values. /// </para> /// </remarks> /// <param name="timestamp"> /// The timestamp whose milliseconds since the Unix epoch should be used as the version value. It must be specified in UTC. /// </param> public BigtableVersion(DateTime timestamp) { GaxPreconditions.CheckArgument( timestamp.Kind == DateTimeKind.Utc, nameof(timestamp), $"The {nameof(BigtableVersion)} timestamp must be specified in UTC."); GaxPreconditions.CheckArgumentRange( timestamp, nameof(timestamp), UnixEpoch, DateTime.MaxValue); _micros = MicrosFromTimestamp(timestamp); }
/// <summary> /// Streams back the contents of all requested rows in key order, optionally /// applying the same Reader filter to each. /// </summary> /// <remarks> /// <para> /// This method simply delegates to <see cref="ReadRows(ReadRowsRequest, CallSettings)"/>. /// </para> /// </remarks> /// <param name="tableName"> /// The unique name of the table from which to read. Must not be null. /// </param> /// <param name="rows"> /// The row keys and/or ranges to read. If null, reads from all rows. /// </param> /// <param name="filter"> /// The filter to apply to the contents of the specified row(s). If null, /// reads the entirety of each row. /// </param> /// <param name="rowsLimit"> /// The read will terminate after committing to N rows' worth of results. /// If null or 0, returns all results. /// </param> /// <param name="callSettings"> /// If not null, applies overrides to this RPC call. /// </param> /// <returns> /// The server stream. /// </returns> public virtual ReadRowsStream ReadRows( TableName tableName, RowSet rows = null, RowFilter filter = null, long?rowsLimit = null, CallSettings callSettings = null) => ReadRows( new ReadRowsRequest { TableNameAsTableName = GaxPreconditions.CheckNotNull(tableName, nameof(tableName)), Rows = rows, Filter = filter, RowsLimit = GaxPreconditions.CheckArgumentRange(rowsLimit ?? 0, nameof(rowsLimit), 0, long.MaxValue) }, callSettings);
internal DocumentChange(DocumentSnapshot document, Type type, int?oldIndex, int?newIndex) { ChangeType = type; Document = document; if (oldIndex != null) { GaxPreconditions.CheckArgumentRange(oldIndex, nameof(oldIndex), 0, int.MaxValue); } if (newIndex != null) { GaxPreconditions.CheckArgumentRange(newIndex, nameof(newIndex), 0, int.MaxValue); } OldIndex = oldIndex; NewIndex = newIndex; }
/// <summary> /// Constructor with complete control that does not perform any validation. /// </summary> internal ResultStream( SpannerClient client, ReadOrQueryRequest request, Session session, CallSettings callSettings, int maxBufferSize, RetrySettings retrySettings) { _buffer = new LinkedList <PartialResultSet>(); _client = GaxPreconditions.CheckNotNull(client, nameof(client)); _request = GaxPreconditions.CheckNotNull(request, nameof(request)); _session = GaxPreconditions.CheckNotNull(session, nameof(session)); _callSettings = callSettings; _maxBufferSize = GaxPreconditions.CheckArgumentRange(maxBufferSize, nameof(maxBufferSize), 1, 10_000); _retrySettings = GaxPreconditions.CheckNotNull(retrySettings, nameof(retrySettings)); }
/// <summary> /// Creates a new instance with the given settings. /// </summary> /// <param name="maxAttempts">The maximum number of attempts to make. Must be positive.</param> /// <param name="initialBackoff">The backoff after the initial failure. Must be non-negative.</param> /// <param name="maxBackoff">The maximum backoff. Must be at least <paramref name="initialBackoff"/>.</param> /// <param name="backoffMultiplier">The multiplier to apply to backoff times. Must be at least 1.0.</param> /// <param name="retryFilter">The predicate to use to check whether an error should be retried. Must not be null.</param> /// <param name="backoffJitter">The jitter to use on each backoff. Must not be null.</param> internal RetrySettings( int maxAttempts, TimeSpan initialBackoff, TimeSpan maxBackoff, double backoffMultiplier, Predicate <Exception> retryFilter, IJitter backoffJitter) { MaxAttempts = GaxPreconditions.CheckArgumentRange(maxAttempts, nameof(maxAttempts), 1, int.MaxValue); InitialBackoff = GaxPreconditions.CheckNonNegativeDelay(initialBackoff, nameof(initialBackoff)); MaxBackoff = GaxPreconditions.CheckNonNegativeDelay(maxBackoff, nameof(maxBackoff)); GaxPreconditions.CheckArgument(maxBackoff >= initialBackoff, nameof(maxBackoff), "Maximum backoff must be at least as large as initial backoff"); BackoffMultiplier = GaxPreconditions.CheckArgumentRange(backoffMultiplier, nameof(backoffMultiplier), 1.0, double.MaxValue); RetryFilter = GaxPreconditions.CheckNotNull(retryFilter, nameof(retryFilter)); BackoffJitter = GaxPreconditions.CheckNotNull(backoffJitter, nameof(backoffJitter)); }
/// <summary> /// Constructor with complete control, for testing purposes. /// </summary> internal SqlResultStream( SpannerClient client, ExecuteSqlRequest request, Session session, CallSettings callSettings, int maxBufferSize, BackoffSettings backoffSettings, IJitter backoffJitter) { _buffer = new LinkedList <PartialResultSet>(); _client = GaxPreconditions.CheckNotNull(client, nameof(client)); _request = GaxPreconditions.CheckNotNull(request, nameof(request)); _session = GaxPreconditions.CheckNotNull(session, nameof(session)); _callSettings = callSettings; _maxBufferSize = GaxPreconditions.CheckArgumentRange(maxBufferSize, nameof(maxBufferSize), 1, 10_000); _backoffSettings = GaxPreconditions.CheckNotNull(backoffSettings, nameof(backoffSettings)); _backoffJitter = GaxPreconditions.CheckNotNull(backoffJitter, nameof(backoffJitter)); }
private async Task <IReadOnlyList <T> > AnnotateSingleFeatureTypeAsync <T>( Feature.Types.Type featureType, Func <AnnotateImageResponse, RepeatedField <T> > annotationExtractor, Image image, ImageContext context, int maxResults, CallSettings callSettings) { GaxPreconditions.CheckNotNull(image, nameof(image)); GaxPreconditions.CheckArgumentRange(maxResults, nameof(maxResults), 0, int.MaxValue); var request = new AnnotateImageRequest { Image = image, ImageContext = context, Features = { new Feature { Type = featureType, MaxResults = maxResults } } }; // This will throw on error. var response = await AnnotateAsync(request, callSettings).ConfigureAwait(false); return(annotationExtractor(response)); }
/// <summary> /// Creates a new endpoint with the given host and port. /// </summary> /// <param name="host">The host name to connect to. Must not be null or empty.</param> /// <param name="port">The port to connect to, in the range 1 to 65535 inclusive.</param> public ServiceEndpoint(string host, int port) { Host = GaxPreconditions.CheckNotNullOrEmpty(host, nameof(host)); Port = GaxPreconditions.CheckArgumentRange(port, nameof(port), 1, 65535); }
public void CheckRangeTDouble_Invalid(double value) { Assert.Throws <ArgumentOutOfRangeException>(() => GaxPreconditions.CheckArgumentRange(value, nameof(value), RangeMin, RangeMax)); }
public void CheckRangeNullableInt32_Valid(int?value) { Assert.Equal(value, GaxPreconditions.CheckArgumentRange(value, nameof(value), RangeMin, RangeMax)); }
public void CheckRangeNullableInt32_Invalid(int?value) { Assert.Throws <ArgumentOutOfRangeException>(() => GaxPreconditions.CheckArgumentRange(value, nameof(value), RangeMin, RangeMax)); }
public void CheckRangeInt64_Valid(long value) { Assert.Equal(value, GaxPreconditions.CheckArgumentRange(value, nameof(value), RangeMin, RangeMax)); }
internal void Validate() { // Fairly arbitrary upper limit. GaxPreconditions.CheckArgumentRange(ClientCount ?? 1, nameof(ClientCount), 1, 256); }
/// <summary> /// Creates a new <see cref="RowFilter"/> instance which matches all cells /// from a row with probability p, and matches no cells from the row with /// probability 1-p. /// </summary> /// <param name="probability"> /// The probability with which rows should be matched. Must be between 0 and 1, inclusive. /// </param> /// <returns>The created row filter.</returns> public static RowFilter RowSample(double probability) => new RowFilter { RowSampleFilter = GaxPreconditions.CheckArgumentRange(probability, nameof(probability), 0.0, 1.0) };
/// <summary> /// Specifies a number of results to skip. /// </summary> /// <remarks> /// This call replaces any previously-specified offset in the query. /// </remarks> /// <param name="offset">The number of results to skip. Must be greater than or equal to 0.</param> /// <returns>A new query based on the current one, but with the specified offset applied.</returns> public Query Offset(int offset) { GaxPreconditions.CheckArgumentRange(offset, nameof(offset), 0, int.MaxValue); return(new Query(Collection, offset, _limit, _orderings, _filters, _projections, _startAt, _endAt)); }
/// <summary> /// Initializes a new instance of the <see cref="PlatformApiEndpoint" /> class. /// Creates a new endpoint with the given host and port. /// </summary> /// <param name="host">The host name to connect to. Must not be null or empty.</param> /// <param name="port">The port to connect to, in the range 1 to 65535 inclusive.</param> /// <param name="insecure"> /// Whether the connection is encrypted or not. For unencrypted connections no authentication data /// is sent. /// </param> public PlatformApiEndpoint(string host, int port, bool insecure = false) { Host = GaxPreconditions.CheckNotNullOrEmpty(host, nameof(host)); Port = GaxPreconditions.CheckArgumentRange(port, nameof(port), 1, 65535); Insecure = insecure; }
/// <summary> /// Creates a new value using the provided latitude and longitude values. /// </summary> /// <param name="latitude">The latitude of the point in degrees, between -90 and 90 inclusive.</param> /// <param name="longitude">The longitude of the point in degrees, between -180 and 180 inclusive.</param> public GeoPoint(double latitude, double longitude) { _latitude = GaxPreconditions.CheckArgumentRange(latitude, nameof(latitude), -90d, 90d); _longitude = GaxPreconditions.CheckArgumentRange(longitude, nameof(longitude), -180d, 180d); }
/// <summary> /// Creates an instance with the given maximum number of attempts. /// </summary> /// <param name="maxAttempts">The number of times a transaction will be attempted before failing. Must be positive.</param> /// <returns>A new options object.</returns> public static TransactionOptions Create(int maxAttempts) { GaxPreconditions.CheckArgumentRange(maxAttempts, nameof(maxAttempts), 1, int.MaxValue); return(new TransactionOptions(maxAttempts)); }
public void CheckRangeTDouble_Valid(double value) { Assert.Equal(value, GaxPreconditions.CheckArgumentRange(value, nameof(value), RangeMin, RangeMax)); }