public AsyncQueryExecutor ( AsyncCluster cluster, QueryPolicy policy, RecordSequenceListener listener, Statement statement, Node[] nodes ) : base(cluster) { this.listener = listener; statement.Prepare(true); // Create commands. AsyncQuery[] tasks = new AsyncQuery[nodes.Length]; int count = 0; foreach (Node node in nodes) { tasks[count++] = new AsyncQuery(this, cluster, (AsyncNode)node, policy, listener, statement); } // Dispatch commands to nodes. if (policy.failOnClusterChange) { ExecuteValidate(tasks, policy.maxConcurrentNodes, statement.ns); } else { Execute(tasks, policy.maxConcurrentNodes); } }
public QueryRecordCommand(QueryPolicy policy, Statement statement, RecordSet recordSet, ulong clusterKey, bool first) : base(statement.ns, clusterKey, first) { this.policy = policy; this.statement = statement; this.recordSet = recordSet; }
public QueryAggregateExecutor(Cluster cluster, QueryPolicy policy, Statement statement) : base(cluster, policy, statement) { inputQueue = new BlockingCollection <object>(500); resultSet = new ResultSet(this, policy.recordQueueSize, cancel.Token); InitializeThreads(); }
public QueryAggregateExecutor(Cluster cluster, QueryPolicy policy, Statement statement) : base(cluster, policy, statement) { inputQueue = new BlockingCollection<object>(500); resultSet = new ResultSet(this, policy.recordQueueSize, cancel.Token); InitializeThreads(); }
/// <summary> /// Copy client policy from another client policy. /// </summary> public ClientPolicy(ClientPolicy other) { this.user = other.user; this.password = other.password; this.clusterName = other.clusterName; this.authMode = other.authMode; this.timeout = other.timeout; this.loginTimeout = other.loginTimeout; this.maxConnsPerNode = other.maxConnsPerNode; this.connPoolsPerNode = other.connPoolsPerNode; this.maxSocketIdle = other.maxSocketIdle; this.tendInterval = other.tendInterval; this.failIfNotConnected = other.failIfNotConnected; this.readPolicyDefault = new Policy(other.readPolicyDefault); this.writePolicyDefault = new WritePolicy(other.writePolicyDefault); this.scanPolicyDefault = new ScanPolicy(other.scanPolicyDefault); this.queryPolicyDefault = new QueryPolicy(other.queryPolicyDefault); this.batchPolicyDefault = new BatchPolicy(other.batchPolicyDefault); this.infoPolicyDefault = new InfoPolicy(other.infoPolicyDefault); this.tlsPolicy = (other.tlsPolicy != null) ? new TlsPolicy(other.tlsPolicy) : null; this.ipMap = other.ipMap; this.useServicesAlternate = other.useServicesAlternate; this.rackAware = other.rackAware; this.rackId = other.rackId; }
public AsyncQueryExecutor(AsyncCluster cluster, QueryPolicy policy, RecordSequenceListener listener, Statement statement) { this.listener = listener; statement.Prepare(true); Node[] nodes = cluster.Nodes; if (nodes.Length == 0) { throw new AerospikeException(ResultCode.SERVER_NOT_AVAILABLE, "Query failed because cluster is empty."); } // Create commands. AsyncQuery[] tasks = new AsyncQuery[nodes.Length]; int count = 0; bool hasClusterStable = true; foreach (Node node in nodes) { if (!node.HasClusterStable) { hasClusterStable = false; } tasks[count++] = new AsyncQuery(this, cluster, (AsyncNode)node, policy, listener, statement); } // Dispatch commands to nodes. if (policy.failOnClusterChange && hasClusterStable) { ExecuteValidate(cluster, tasks, policy.maxConcurrentNodes, statement.ns); } else { Execute(tasks, policy.maxConcurrentNodes); } }
public QueryExecutor(Cluster cluster, QueryPolicy policy, Statement statement, Node[] nodes) { this.cluster = cluster; this.policy = policy; this.statement = statement; this.nodes = nodes; this.threads = new QueryThread[nodes.Length]; this.cancel = new CancellationTokenSource(); // Initialize maximum number of nodes to query in parallel. this.maxConcurrentNodes = (policy.maxConcurrentNodes == 0 || policy.maxConcurrentNodes >= threads.Length) ? threads.Length : policy.maxConcurrentNodes; }
public QueryRecordCommand ( Cluster cluster, Node node, QueryPolicy policy, Statement statement, RecordSet recordSet, ulong clusterKey, bool first ) : base(cluster, policy, node, statement.ns, clusterKey, first) { this.statement = statement; this.recordSet = recordSet; }
public QueryAggregateCommand ( QueryPolicy policy, Statement statement, BlockingCollection <object> inputQueue, CancellationToken cancelToken, ulong clusterKey, bool first ) : base(statement.ns, clusterKey, first) { this.policy = policy; this.statement = statement; this.inputQueue = inputQueue; this.cancelToken = cancelToken; }
public QueryExecutor(Cluster cluster, QueryPolicy policy, Statement statement) { this.policy = policy; this.statement = statement; this.cancel = new CancellationTokenSource(); this.nodes = cluster.Nodes; if (this.nodes.Length == 0) { throw new AerospikeException(ResultCode.SERVER_NOT_AVAILABLE, "Query failed because cluster is empty."); } this.threads = new QueryThread[nodes.Length]; // Initialize maximum number of nodes to query in parallel. this.maxConcurrentNodes = (policy.maxConcurrentNodes == 0 || policy.maxConcurrentNodes >= threads.Length) ? threads.Length : policy.maxConcurrentNodes; }
public AsyncQueryPartitionExecutor ( AsyncCluster cluster, QueryPolicy policy, RecordSequenceListener listener, Statement statement, PartitionTracker tracker ) : base(cluster) { this.policy = policy; this.listener = listener; this.statement = statement; this.tracker = tracker; statement.returnData = true; tracker.SleepBetweenRetries = 0; QueryPartitions(); }
public QueryExecutor(Cluster cluster, QueryPolicy policy, Statement statement) { this.policy = policy; this.statement = statement; this.cancel = new CancellationTokenSource(); this.nodes = cluster.Nodes; if (this.nodes.Length == 0) { throw new AerospikeException(ResultCode.SERVER_NOT_AVAILABLE, "Query failed because cluster is empty."); } this.threads = new QueryThread[nodes.Length]; // Initialize maximum number of nodes to query in parallel. this.maxConcurrentNodes = (policy.maxConcurrentNodes == 0 || policy.maxConcurrentNodes >= threads.Length) ? threads.Length : policy.maxConcurrentNodes; }
public QueryPartitionExecutor ( Cluster cluster, QueryPolicy policy, Statement statement, int nodeCapacity, PartitionTracker tracker ) { this.cluster = cluster; this.policy = policy; statement.returnData = true; this.statement = statement; this.threads = new List <QueryThread>(nodeCapacity); this.cancel = new CancellationTokenSource(); this.tracker = tracker; this.recordSet = new RecordSet(this, policy.recordQueueSize, cancel.Token); ThreadPool.QueueUserWorkItem(this.Run); }
public AsyncQueryExecutor(AsyncCluster cluster, QueryPolicy policy, RecordSequenceListener listener, Statement statement) { this.listener = listener; statement.Prepare(true); Node[] nodes = cluster.Nodes; if (nodes.Length == 0) { throw new AerospikeException(ResultCode.SERVER_NOT_AVAILABLE, "Query failed because cluster is empty."); } // Create commands. AsyncQuery[] tasks = new AsyncQuery[nodes.Length]; int count = 0; foreach (Node node in nodes) { tasks[count++] = new AsyncQuery(this, cluster, (AsyncNode)node, policy, listener, statement); } // Dispatch commands to nodes. Execute(tasks, policy.maxConcurrentNodes); }
protected internal void SetQuery(Policy policy, Statement statement, bool write) { byte[] functionArgBuffer = null; int fieldCount = 0; int filterSize = 0; int binNameSize = 0; Begin(); if (statement.ns != null) { dataOffset += ByteUtil.EstimateSizeUtf8(statement.ns) + FIELD_HEADER_SIZE; fieldCount++; } if (statement.indexName != null) { dataOffset += ByteUtil.EstimateSizeUtf8(statement.indexName) + FIELD_HEADER_SIZE; fieldCount++; } if (statement.setName != null) { dataOffset += ByteUtil.EstimateSizeUtf8(statement.setName) + FIELD_HEADER_SIZE; fieldCount++; } // Allocate space for TaskId field. dataOffset += 8 + FIELD_HEADER_SIZE; fieldCount++; if (statement.filter != null) { IndexCollectionType type = statement.filter.CollectionType; if (type != IndexCollectionType.DEFAULT) { dataOffset += FIELD_HEADER_SIZE + 1; fieldCount++; } dataOffset += FIELD_HEADER_SIZE; filterSize++; // num filters filterSize += statement.filter.EstimateSize(); dataOffset += filterSize; fieldCount++; // Query bin names are specified as a field (Scan bin names are specified later as operations) if (statement.binNames != null) { dataOffset += FIELD_HEADER_SIZE; binNameSize++; // num bin names foreach (string binName in statement.binNames) { binNameSize += ByteUtil.EstimateSizeUtf8(binName) + 1; } dataOffset += binNameSize; fieldCount++; } } else { // Calling query with no filters is more efficiently handled by a primary index scan. // Estimate scan options size. dataOffset += 2 + FIELD_HEADER_SIZE; fieldCount++; // Estimate scan timeout size. dataOffset += 4 + FIELD_HEADER_SIZE; fieldCount++; } PredExp[] predExp = statement.PredExp; int predSize = 0; if (predExp != null) { dataOffset += FIELD_HEADER_SIZE; predSize = PredExp.EstimateSize(predExp); dataOffset += predSize; fieldCount++; } if (statement.functionName != null) { dataOffset += FIELD_HEADER_SIZE + 1; // udf type dataOffset += ByteUtil.EstimateSizeUtf8(statement.packageName) + FIELD_HEADER_SIZE; dataOffset += ByteUtil.EstimateSizeUtf8(statement.functionName) + FIELD_HEADER_SIZE; if (statement.functionArgs.Length > 0) { functionArgBuffer = Packer.Pack(statement.functionArgs); } else { functionArgBuffer = new byte[0]; } dataOffset += FIELD_HEADER_SIZE + functionArgBuffer.Length; fieldCount += 4; } if (statement.filter == null) { if (statement.binNames != null) { foreach (string binName in statement.binNames) { EstimateOperationSize(binName); } } } SizeBuffer(); int operationCount = (statement.filter == null && statement.binNames != null) ? statement.binNames.Length : 0; if (write) { WriteHeader((WritePolicy)policy, Command.INFO1_READ, Command.INFO2_WRITE, fieldCount, operationCount); } else { QueryPolicy qp = (QueryPolicy)policy; int readAttr = qp.includeBinData ? Command.INFO1_READ : Command.INFO1_READ | Command.INFO1_NOBINDATA; WriteHeader(policy, readAttr, 0, fieldCount, operationCount); } if (statement.ns != null) { WriteField(statement.ns, FieldType.NAMESPACE); } if (statement.indexName != null) { WriteField(statement.indexName, FieldType.INDEX_NAME); } if (statement.setName != null) { WriteField(statement.setName, FieldType.TABLE); } // Write taskId field WriteFieldHeader(8, FieldType.TRAN_ID); ByteUtil.LongToBytes(statement.taskId, dataBuffer, dataOffset); dataOffset += 8; if (statement.filter != null) { IndexCollectionType type = statement.filter.CollectionType; if (type != IndexCollectionType.DEFAULT) { WriteFieldHeader(1, FieldType.INDEX_TYPE); dataBuffer[dataOffset++] = (byte)type; } WriteFieldHeader(filterSize, FieldType.INDEX_RANGE); dataBuffer[dataOffset++] = (byte)1; dataOffset = statement.filter.Write(dataBuffer, dataOffset); // Query bin names are specified as a field (Scan bin names are specified later as operations) if (statement.binNames != null) { WriteFieldHeader(binNameSize, FieldType.QUERY_BINLIST); dataBuffer[dataOffset++] = (byte)statement.binNames.Length; foreach (string binName in statement.binNames) { int len = ByteUtil.StringToUtf8(binName, dataBuffer, dataOffset + 1); dataBuffer[dataOffset] = (byte)len; dataOffset += len + 1; } } } else { // Calling query with no filters is more efficiently handled by a primary index scan. WriteFieldHeader(2, FieldType.SCAN_OPTIONS); byte priority = (byte)policy.priority; priority <<= 4; dataBuffer[dataOffset++] = priority; dataBuffer[dataOffset++] = (byte)100; // Write scan timeout WriteFieldHeader(4, FieldType.SCAN_TIMEOUT); dataOffset += ByteUtil.IntToBytes((uint)policy.socketTimeout, dataBuffer, dataOffset); } if (predExp != null) { WriteFieldHeader(predSize, FieldType.PREDEXP); dataOffset = PredExp.Write(predExp, dataBuffer, dataOffset); } if (statement.functionName != null) { WriteFieldHeader(1, FieldType.UDF_OP); dataBuffer[dataOffset++] = (statement.returnData) ? (byte)1 : (byte)2; WriteField(statement.packageName, FieldType.UDF_PACKAGE_NAME); WriteField(statement.functionName, FieldType.UDF_FUNCTION); WriteField(functionArgBuffer, FieldType.UDF_ARGLIST); } // Scan bin names are specified after all fields. if (statement.filter == null) { if (statement.binNames != null) { foreach (string binName in statement.binNames) { WriteOperation(binName, Operation.Type.READ); } } } End(); }
//-------------------------------------------------------- // Query functions (Supported by Aerospike 3 servers only) //-------------------------------------------------------- /// <summary> /// Execute query and call action for each record returned from server. /// </summary> /// <param name="policy">generic configuration parameters, pass in null for defaults</param> /// <param name="statement">database query command</param> /// <param name="action">action methods to be called for each record</param> /// <exception cref="AerospikeException">if query fails</exception> public void Query(QueryPolicy policy, Statement statement, Action<Key, Record> action) { using (RecordSet rs = Query(policy, statement)) { while (rs.Next()) { action(rs.Key, rs.Record); } } }
public PartitionTracker(QueryPolicy policy, Node[] nodes, PartitionFilter filter) : this((Policy)policy, nodes, filter) { this.maxRecords = policy.maxRecords; }
public PartitionTracker(QueryPolicy policy, Node[] nodes) : this((Policy)policy, nodes) { this.maxRecords = policy.maxRecords; }
/// <summary> /// Execute query and return record iterator. The query executor puts records on a queue in /// separate threads. The calling thread concurrently pops records off the queue through the /// record iterator. /// <para> /// This method is only supported by Aerospike 3 servers. /// </para> /// </summary> /// <param name="policy">generic configuration parameters, pass in null for defaults</param> /// <param name="statement">database query command</param> /// <exception cref="AerospikeException">if query fails</exception> public RecordSet Query(QueryPolicy policy, Statement statement) { if (policy == null) { policy = queryPolicyDefault; } QueryRecordExecutor executor = new QueryRecordExecutor(cluster, policy, statement); executor.Execute(); return executor.RecordSet; }
/// <summary> /// Execute query, apply statement's aggregation function, and return result iterator. /// The aggregation function should be located in a Lua script file that can be found from the /// "LuaConfig.PackagePath" paths static variable. The default package path is "udf/?.lua" /// where "?" is the packageName. /// <para> /// The query executor puts results on a queue in separate threads. The calling thread /// concurrently pops results off the queue through the ResultSet iterator. /// The aggregation function is called on both server and client (final reduce). /// Therefore, the Lua script file must also reside on both server and client. /// </para> /// <para> /// This method is only supported by Aerospike 3 servers. /// </para> /// </summary> /// <param name="policy">generic configuration parameters, pass in null for defaults</param> /// <param name="statement">database query command</param> /// <param name="packageName">server package where user defined function resides</param> /// <param name="functionName">aggregation function name</param> /// <param name="functionArgs">arguments to pass to function name, if any</param> /// <exception cref="AerospikeException">if query fails</exception> public ResultSet QueryAggregate(QueryPolicy policy, Statement statement, string packageName, string functionName, params Value[] functionArgs) { statement.SetAggregateFunction(packageName, functionName, functionArgs); return QueryAggregate(policy, statement); }
/// <summary> /// Execute query, apply statement's aggregation function, call action for each aggregation /// object returned from server. /// </summary> /// <param name="policy">generic configuration parameters, pass in null for defaults</param> /// <param name="statement">database query command with aggregate functions already initialized by SetAggregateFunction()</param> /// <param name="action">action methods to be called for each aggregation object</param> /// <exception cref="AerospikeException">if query fails</exception> public void QueryAggregate(QueryPolicy policy, Statement statement, Action<Object> action) { using (ResultSet rs = QueryAggregate(policy, statement)) { while (rs.Next()) { action(rs.Object); } } }
//------------------------------------------------------- // Query Operations //------------------------------------------------------- /// <summary> /// Asynchronously execute query on all server nodes. The query policy's /// <code>maxConcurrentNodes</code> dictate how many nodes can be queried in parallel. /// The default is to query all nodes in parallel. /// <para> /// This method schedules the node's query commands with channel selectors and returns. /// Selector threads will process the commands and send the results to the listener. /// </para> /// </summary> /// <param name="policy">query configuration parameters, pass in null for defaults</param> /// <param name="listener">where to send results</param> /// <param name="statement">database query command parameters</param> /// <exception cref="AerospikeException">if query fails</exception> public void Query(QueryPolicy policy, RecordSequenceListener listener, Statement statement) { if (policy == null) { policy = queryPolicyDefault; } new AsyncQueryExecutor(cluster, policy, listener, statement); }
/// <summary> /// Execute query, apply statement's aggregation function, and return result iterator. /// The aggregation function should be initialized via the statement's SetAggregateFunction() /// and should be located in a Lua resource file located in an assembly. /// <para> /// The query executor puts results on a queue in separate threads. The calling thread /// concurrently pops results off the queue through the ResultSet iterator. /// The aggregation function is called on both server and client (final reduce). /// Therefore, the Lua script file must also reside on both server and client. /// </para> /// <para> /// This method is only supported by Aerospike 3 servers. /// </para> /// </summary> /// <param name="policy">generic configuration parameters, pass in null for defaults</param> /// <param name="statement">database query command with aggregate functions already initialized by SetAggregateFunction()</param> /// <exception cref="AerospikeException">if query fails</exception> public ResultSet QueryAggregate(QueryPolicy policy, Statement statement) { if (policy == null) { policy = queryPolicyDefault; } statement.Prepare(true); QueryAggregateExecutor executor = new QueryAggregateExecutor(cluster, policy, statement); executor.Execute(); return executor.ResultSet; }
/// <summary> /// Initialize Aerospike client with suitable hosts to seed the cluster map. /// The client policy is used to set defaults and size internal data structures. /// For each host connection that succeeds, the client will: /// <list type="bullet"> /// <item>Add host to the cluster map</item> /// <item>Request host's list of other nodes in cluster</item> /// <item>Add these nodes to cluster map</item> /// </list> /// <para> /// In most cases, only one host is necessary to seed the cluster. The remaining hosts /// are added as future seeds in case of a complete network failure. /// </para> /// <para> /// If one connection succeeds, the client is ready to process database requests. /// If all connections fail and the policy's failIfNotConnected is true, a connection /// exception will be thrown. Otherwise, the cluster will remain in a disconnected state /// until the server is activated. /// </para> /// </summary> /// <param name="policy">client configuration parameters, pass in null for defaults</param> /// <param name="hosts">array of potential hosts to seed the cluster</param> /// <exception cref="AerospikeException">if all host connections fail</exception> public AerospikeClient(ClientPolicy policy, params Host[] hosts) { if (policy == null) { policy = new ClientPolicy(); } this.readPolicyDefault = policy.readPolicyDefault; this.writePolicyDefault = policy.writePolicyDefault; this.scanPolicyDefault = policy.scanPolicyDefault; this.queryPolicyDefault = policy.queryPolicyDefault; this.batchPolicyDefault = policy.batchPolicyDefault; this.infoPolicyDefault = policy.infoPolicyDefault; cluster = new Cluster(policy, hosts); cluster.InitTendThread(policy.failIfNotConnected); }
/// <summary> /// Construct client without initialization. /// Should only be used by classes inheriting from this client. /// </summary> protected internal AerospikeClient(ClientPolicy policy) { if (policy != null) { this.readPolicyDefault = policy.readPolicyDefault; this.writePolicyDefault = policy.writePolicyDefault; this.scanPolicyDefault = policy.scanPolicyDefault; this.queryPolicyDefault = policy.queryPolicyDefault; this.batchPolicyDefault = policy.batchPolicyDefault; this.infoPolicyDefault = policy.infoPolicyDefault; } else { this.readPolicyDefault = new Policy(); this.writePolicyDefault = new WritePolicy(); this.scanPolicyDefault = new ScanPolicy(); this.queryPolicyDefault = new QueryPolicy(); this.batchPolicyDefault = new BatchPolicy(); this.infoPolicyDefault = new InfoPolicy(); } }