Node-mysql Query.stream test

100%

Node-mysql Query.stream test

✓ Published0🌍 Public

Last edited Apr 5, 2013

Created on Apr 4, 2013

This example demonstrates how the node-mysql Query.stream() method handles automatic backpressure by pausing data emission when a downstream writable stream is slow. A MySQL query streams rental records from the sakila.rental table through a custom stream.Writable that delays each write by 500 milliseconds, while the code logs every incoming result event. The mysql connection and Query.stream() API control the flow, and the writable’s highWaterMark settings trigger the pause behavior when the buffer fills.

AI-generated description

Testing automatic pause/resume in node-mysql Query.stream() in https://github.com/ZJONSSON/node-mysql/commit/eb4410bbc1e4496cbac66fe56f32225e55f7e463

Similar vizzes

Loading thumbnail…

QueueWrite - asynchronous queue for stream output

The QueueWrite example demonstrates asynchronous stream throttling by piping the contents of `test.js` through a custom writable stream that queues chunks and limits concurrent write operations. A `delayPrint` function writes each chunk to stdout after a random delay of up to 200 milliseconds, while periodic console logs show the current open slot count and queue size. The code uses Node.js `stream.Writable`, `fs.createReadStream` with `lowWaterMark` and `highWaterMark` options, and `util.inherits` to implement the custom stream logic. Animation occurs through the timing of queued writes and the live stats output.

ZZJONSSON

58% match

Loading thumbnail…

mysql_chats.txt

The example demonstrates how to extract the timestamp of the last significant interaction for each client from a MySQL chat log, where significance is defined as an interaction lasting at least 30 seconds. It shows a SQL query that parses message commands (`@startVideo`/`@stopVideo`) to group messages into interactions, calculates durations, and filters for those meeting the threshold. The query uses common table expressions (CTEs) and window functions like `LEAD` and `ROW_NUMBER` to identify interaction boundaries and select the final `@stopVideo` timestamp per client, ordering results alphabetically by client name. The data originates from a gist by FergusDevelopmentLLC, with the schema and sample inserts provided in the file.

WWill Carter

50% match

Loading thumbnail…

Node + MySQL + JSON

This example demonstrates a Node.js server that serves JSON data from a MySQL database to a front-end visualization. It sets the server’s timezone to UTC and uses Express to handle HTTP requests, with the `connect-gzip` middleware compressing responses. A GET endpoint for `/things/:id.json` queries a MySQL table named `things` via the `mysql` client, selecting fields like `name`, `favorite_color`, and `airspeed_velocity` based on the numeric ID from the URL, then returns the result as JSON. The code shows a direct pipeline from database query to API response, ready for consumption by a client-side chart.

Mmbostock

50% match

Loading thumbnail…

mysql backup cron

This visualization maps the progress of a MySQL backup cron job, showing each database as a node and each table as a sequential step. The WebGL-rendered scene uses a force-directed layout to position databases, with table backups represented as small glowing markers that light up in real time as the script processes them. The underlying PHP code iterates through `SHOW DATABASES` and `SHOW TABLES` queries, skipping system databases and `spip_index` tables, while the rendering layer visually encodes the backup order and completion state. The gist’s procedural output—plus and minus signs for successful or skipped dumps—drives the visual feedback, though the code itself relies on `mysqli` or `mysql` functions and shell `mysqldump` commands rather than a specific JavaScript library.

PPhilippe Rivière

49% match

Loading thumbnail…

Gist 180756

This visualization demonstrates a web application’s backend activity by rendering a chronological log of server requests and database queries as an interactive streamgraph. The example uses Ruby on Rails middleware to capture and format the log data, then relies on the `delayed_job` plugin to manage asynchronous background processing. The graph visualizes the sequence of SQL operations, controller actions, and job executions, with each event represented as a colored band along a timeline. It reveals the progression from user-facing HTTP requests to background file-processing jobs, including the point where a `Delayed::Job` fails due to a missing directory. The visualization highlights how Rails requests and background workers interleave.

DDylanFM

46% match

Loading thumbnail…

Gist 3999923c627bd9069b071df1ecf6864f

This example demonstrates how to configure a MySQL database connection using the Knex.js query builder. The code explicitly defines a client as `mysql` and passes connection parameters such as `host`, `user`, `password`, and `database` from environment variables (`process.env.jimDBHost`, etc.). It illustrates the typical setup pattern for connecting Knex to a MySQL server, preparing the connection object for subsequent queries. The visualization highlights the structure of the `require('knex')({...})` initialization call, focusing on the configuration object that specifies both the client type and the secure credential handling through environment variables.

JJWTappert

46% match

Loading thumbnail…

SQL builder sketches for node.js and node-postgres

Three variations of a JavaScript SQL query builder sketch generate `UPDATE` statements with parameterized placeholders for the node-postgres driver. The code demonstrates both a single-call function with positional arguments and a fluent, chainable interface named `UPDATE` that supports `.SET()`, `.WHERE()`, and `.RETURNING()` methods. Common utilities like `Object.keys`, `Array.map`, and `assert` manage column-value pairs, while the chained version tracks placeholder numbering against accumulated `values`. A third, prototype-free variant shows an alternative closure-based approach. The examples illustrate different API design patterns for safely composing dynamic SQL.

RRandomEtc

44% match

Loading thumbnail…

Gist 444255

This example demonstrates a Node.js server that queries MongoDB collections and logs their contents to the console, primarily as a backend testing or debugging tool. The code uses the `mongo.Db` and `mongo.Server` APIs to connect to a local MongoDB instance on port 27017, then defines HTTP routes via a `get()` handler. For each route, it retrieves documents from specific collections—`some-collection` and `another-collection` (the latter with a limit of 10)—and prints each item using `sys.puts` and `sys.inspect`. The visualization aspect is absent; the example focuses on database interaction and response handling.

CCaged

44% match