view release on metacpan or  search on metacpan

lib/Net/Etcd.pm  view on Meta::CPAN

    my @users = $range->all

    # delete single key
    $etcd->deleterange({ key => 'test0' });

    # watch key range, streaming.
    $watch = $etcd->watch( { key => 'foo', range_end => 'fop'}, sub {
        my ($result) =  @_;
        print STDERR Dumper($result);
    })->create;

 view release on metacpan or  search on metacpan

Changes  view on Meta::CPAN

    * Add mapping from backends to directors and directors to origins

0.8 2011-11-03

    * Add list_* to all objects
    * Add Healthchecks and Syslog endpoint streaming

0.7 2011-11-02

    * Fix stupid bug in fastly_upload_vcl

 view release on metacpan or  search on metacpan

lib/Net/Flowdock/Stream.pm  view on Meta::CPAN

      }
  }

=head1 DESCRIPTION

This module implements the streaming api for
L<Flowdock|https://www.flowdock.com/>. It provides a non-blocking method which
you can call to get the next available event in the stream. You can then
integrate this method into your existing event-driven app.

=head1 ATTRIBUTES

 view release on metacpan or  search on metacpan

lib/Net/FullAuto/FA_Core.pm  view on Meta::CPAN

   spl => 'application/futuresplash',
   spr => 'application/x-sprite',
   sprite => 'application/x-sprite',
   src => 'application/x-wais-source',
   ssi => 'text/x-server-parsed-html',
   ssm => 'application/streamingmedia',
   sst => 'application/vnd.ms-pki.certstore',
   step => 'application/step',
   stl => 'application/sla',
   #stl => 'application/vnd.ms-pki.stl',
   #stl => 'application/x-navistyle',

 view release on metacpan or  search on metacpan

lib/Net/HTTP2/nghttp2.pm  view on Meta::CPAN

    # Later, when data becomes available:
    $session->resume_stream($stream_id);

=head2 Streaming Request

Client-side requests also support streaming body callbacks, using the same
callback signature as streaming responses. This is essential for bidirectional
protocols like WebSocket over HTTP/2 (RFC 8441), where the client stream must
remain open for ongoing data exchange.

    my @send_queue;
    my $eof = 0;

lib/Net/HTTP2/nghttp2.pm  view on Meta::CPAN

            # This is a WebSocket upgrade request
        }
        return 0;
    },

    # Accept with 200 (not 101) and a streaming body for server-to-client:
    $session->submit_response($stream_id,
        status  => 200,
        headers => [['sec-websocket-protocol', $subprotocol]],
        body    => sub {
            my ($stream_id, $max_length) = @_;
            # Return WebSocket frames to send to client
            return undef;  # Defer until data ready
        },
    );

B<Client side> - send extended CONNECT with streaming body:

    my $stream_id = $session->submit_request(
        method    => 'CONNECT',
        path      => '/chat',
        scheme    => 'https',

 view release on metacpan or  search on metacpan

lib/Net/IANA/Services.pm  view on Meta::CPAN

our $IANA_REGEX_PORTS = qr{\b(?<!-)(?:1(?:1(?:1(?:[234589]|0[345689]?|6[12345]?|7[12345]?|1[012]?)?|3(?:[034589]|2[01]?|19?|67?|71?)?|7(?:[0134678]|2[03]?|51?|96?)?|2(?:[23456789]|0[128]?|1?1)?|9(?:[01234578]|9[789]?|67?)?|0(?:[1234678]|0[01]?|9?5)?|...



our $IANA_REGEX_SERVICES = qr{\b(?<![-])(?:s(?:e(?:[pt]|r(?:v(?:e(?:r(?:view(?:-(?:asn?|icc|gf|rm)|dbms)|-find|graph|start|wsd2)|xec)|i(?:ce(?:-ctrl|meter|tags)|staitsm)|s(?:erv|tat))|comm-(?:scadmin|wlink)|ialgateway|aph)|c(?:-(?:t4net-(?:clt|srv)|p...



our $IANA_REGEX_PORTS_DCCP = qr{\b(?<!-)(?:1(?:02[12]|113)|500[45]|4556|6514|9)\b}i;  ## no critic(RegularExpressions)

lib/Net/IANA/Services.pm  view on Meta::CPAN

our $IANA_REGEX_SERVICES_SCTP = qr{\b(?<![-])(?:a(?:sap-sctp(?:-tls)?|(?:hs|mq)p|25-fap-fgw|urora|ds-c)|s(?:i(?:mco|ps?)|(?:bc|gs)ap|1-control|mbdirect|sh|ua)|i(?:u(?:hsctpassoc|a)|tu-bicc-stc|pfixs?)|m(?:2(?:[pu]a|ap)|3(?:ap|ua)|egaco-h248)|wme(?:re...



our $IANA_REGEX_SERVICES_TCP = qr{\b(?<![-])(?:s(?:e(?:[pt]|r(?:v(?:e(?:r(?:view(?:-(?:asn?|icc|gf|rm)|dbms)|-find|graph|start|wsd2)|xec)|i(?:ce(?:-ctrl|meter|tags)|staitsm)|stat)|comm-(?:scadmin|wlink)|ialgateway|aph)|c(?:-(?:t4net-(?:clt|srv)|pc2fa...



our $IANA_REGEX_SERVICES_UDP = qr{\b(?<![-])(?:s(?:u(?:[am]|n(?:-(?:s(?:r-(?:iiop(?:-aut|s)?|https?|jm[sx]|admin)|ea-port)|as-(?:j(?:mxrmi|pda)|iiops(?:-ca)?|nodeagt)|user-https|mc-grp|dr|lm)|c(?:acao-(?:(?:jmx|sn)mp|websvc|csa|rmi)|luster(?:geo|mgr)...




####################

 view release on metacpan or  search on metacpan

lib/Net/IMP/HTTP.pm  view on Meta::CPAN

our @EXPORT;

# create and export NET_IMP_HTTP* constants
push @EXPORT, IMP_DATA( 'http',
    'header'     => +1,
    'body'       => -2, # message body: streaming
    'chkhdr'     => +3,
    'chktrailer' => +4,
    'data'       => -5, # encapsulated data (websocket etc): streaming
    'junk'       => -6, # junk data (leading empty lines..): streaming
);

push @EXPORT, IMP_DATA( 'httprq[http+10]',
    'header'     => +1,
    'content'    => -2, # unchunked, uncompressed content: streaming
    'data'       => -3, # encapsulated data (websocket etc): streaming
);


__END__

 view release on metacpan or  search on metacpan

lib/Net/IMP.pm  view on Meta::CPAN

our %EXPORT_TAGS = ( log => \@log_levels );

# data types/protocols
# These two are the basic types, more application specific types might
# be defined somewhere else and be mapped to a number within supported_dtypes.
# The only important thing is, that streaming data should be <0, while
# packetized data (like HTTP header or UDP datagrams) should be > 0
# If no explicit type is given in sub data, it will assume IMP_DATA_STREAM.
use constant IMP_DATA_STREAM  => dualvar(-1,'imp.data.stream');
use constant IMP_DATA_PACKET  => dualvar(+1,'imp.data.packet');

lib/Net/IMP.pm  view on Meta::CPAN

    package Net::IMP::HTTP;
    use Net::IMP 'IMP_DATA';
    use Exporter 'import';
    our @EXPORT = IMP_DATA('http',
	'header' => +1,   # packet type
	'body'   => -2,   # streaming type
	...
    );

=head1 DESCRIPTION

lib/Net/IMP.pm  view on Meta::CPAN

=over 4

=item IMP_DATA_STREAM (-1)

This is for generic streaming data, e.g. chunks from these datatypes can be
concatenated and analyzed together, parts can be replaced etc.

=item IMP_DATA_PACKET (+1)

This is for generic packetized data, where each chunk (e.g. call to C<data>)

lib/Net/IMP.pm  view on Meta::CPAN

=back

All other data types are considered either subtypes of IMP_DATA_PACKET
(value >0) or of IMP_DATA_STREAM (value<0) and share their restrictions.
Also only streaming data of the same type can be concatenated and
analyzed together.

Results will be delivered through the callback or via C<poll_results>.

=item $analyzer->poll_results => @results

lib/Net/IMP.pm  view on Meta::CPAN

The function C<IMP_DATA> is provided to simplify definition of new data types,
for example:

    our @EXPORT = IMP_DATA('http',
	'header'  => +1,   # packet type
	'body'    => -2,   # streaming type
	...
    );
    push @EXPORT = IMP_DATA('httprq[http+10]',
	'header'  => +1,   # packet type
	'content' => -2,   # streaming type
	...
    );

This call of IMP_DATA is equivalent to the following perl declaration:

 view release on metacpan or  search on metacpan

lib/Net/Icecast/Source.pm  view on Meta::CPAN

######################

=head1 NAME

Net::Icecast::Source - Icecast streaming source

=head1 SYNOPSIS

	use Net::Icecast::Source;
	my $source = new Net::Icecast::Source(

lib/Net/Icecast/Source.pm  view on Meta::CPAN

			aim => 'lindenstacker',
			url => 'http://icecast.org',
		},
	);

	# attempt to connect to the streaming server
	$source->connect
		or die "Unable to connect to server: $!\n";
		
	# attempt to log in to the specified mountpoint
	$source->login

 view release on metacpan or  search on metacpan

lib/Net/NATS/Streaming/Client.pm  view on Meta::CPAN

  # Close stream
  $client->close_stream();

=head1 REPOSITORY

L<https://github.com/sergeykolychev/perl-nats-streaming>

=head1 SEE ALSO

L<https://github.com/carwynmoore/perl-nats>
Net::NATS::Client

 view release on metacpan or  search on metacpan

lib/Net/NATS/Streaming/PB.pm  view on Meta::CPAN

=cut

=head1 REPOSITORY

L<https://github.com/sergeykolychev/perl-nats-streaming>

=head1 COPYRIGHT & LICENSE

    Copyright (C) 2017 by Sergey Kolychev <sergeykolychev.github@gmail.com>

 view release on metacpan or  search on metacpan

lib/Net/Nostr/LiveActivity.pm  view on Meta::CPAN

use Class::Tiny qw(
    identifier
    title
    summary
    image
    streaming
    recording
    starts
    ends
    status
    current_participants

lib/Net/Nostr/LiveActivity.pm  view on Meta::CPAN

    my $identifier = delete $args{identifier}
        // croak "live_event requires 'identifier'";
    my $title                = delete $args{title};
    my $summary              = delete $args{summary};
    my $image                = delete $args{image};
    my $streaming            = delete $args{streaming};
    my $recording            = delete $args{recording};
    my $starts               = delete $args{starts};
    my $ends                 = delete $args{ends};
    my $status               = delete $args{status};
    my $current_participants = delete $args{current_participants};

lib/Net/Nostr/LiveActivity.pm  view on Meta::CPAN

    my @tags;
    push @tags, ['d', $identifier];
    push @tags, ['title', $title]         if defined $title;
    push @tags, ['summary', $summary]     if defined $summary;
    push @tags, ['image', $image]         if defined $image;
    push @tags, ['streaming', $streaming] if defined $streaming;
    push @tags, ['recording', $recording] if defined $recording;
    push @tags, ['starts', $starts]       if defined $starts;
    push @tags, ['ends', $ends]           if defined $ends;
    push @tags, ['status', $status]       if defined $status;
    push @tags, ['current_participants', $current_participants]

lib/Net/Nostr/LiveActivity.pm  view on Meta::CPAN

        my $t = $tag->[0];
        if    ($t eq 'd')                    { $attrs{identifier} = $tag->[1] }
        elsif ($t eq 'title')                { $attrs{title} = $tag->[1] }
        elsif ($t eq 'summary')              { $attrs{summary} = $tag->[1] }
        elsif ($t eq 'image')                { $attrs{image} = $tag->[1] }
        elsif ($t eq 'streaming')            { $attrs{streaming} = $tag->[1] }
        elsif ($t eq 'recording')            { $attrs{recording} = $tag->[1] }
        elsif ($t eq 'starts')               { $attrs{starts} = $tag->[1] }
        elsif ($t eq 'ends')                 { $attrs{ends} = $tag->[1] }
        elsif ($t eq 'status')               { $attrs{status} = $tag->[1] }
        elsif ($t eq 'current_participants') { $attrs{current_participants} = $tag->[1] }

lib/Net/Nostr/LiveActivity.pm  view on Meta::CPAN

=head1 SYNOPSIS

    use Net::Nostr::LiveActivity;

    # Live streaming event (kind 30311)
    my $event = Net::Nostr::LiveActivity->live_event(
        pubkey     => $hex_pubkey,
        identifier => 'my-stream',
        title      => 'My Stream',
        status     => 'live',

lib/Net/Nostr/LiveActivity.pm  view on Meta::CPAN

=over 4

=item * B<Live Streaming Event> (kind 30311) - An addressable event
advertising a live stream. Contains tags for title, summary, image,
streaming URL, recording URL, start/end times, status, participant
counts, hashtags, participant roles, relay lists, and pinned chat
messages. Updated continuously as participants join and leave.

=item * B<Live Chat Message> (kind 1311) - A regular event for live
chat. MUST include an C<a> tag referencing the parent live activity.

lib/Net/Nostr/LiveActivity.pm  view on Meta::CPAN

        pubkey               => $hex_pubkey,       # required
        identifier           => $id,               # required (d tag)
        title                => $title,            # optional
        summary              => $summary,          # optional
        image                => $url,              # optional
        streaming            => $url,              # optional
        recording            => $url,              # optional
        starts               => $timestamp,        # optional
        ends                 => $timestamp,        # optional
        status               => $status,           # optional (planned/live/ended)
        current_participants => $count,            # optional

lib/Net/Nostr/LiveActivity.pm  view on Meta::CPAN

        participants         => [[$pk, $relay, $role, $proof], ...], # optional (p tags)
        relays               => [$url, ...],       # optional (relays tag)
        pinned               => [$event_id, ...],  # optional (pinned tags)
    );

Creates a kind 30311 live streaming L<Net::Nostr::Event>. Each C<p>
tag SHOULD have a displayable role name (e.g. C<Host>, C<Speaker>,
C<Participant>). The relay and proof fields in participant entries are
optional. Content defaults to C<''>.

=head2 chat_message

lib/Net/Nostr/LiveActivity.pm  view on Meta::CPAN

=head2 image

Preview image URL.

=head2 streaming

Live stream URL (kind 30311).

=head2 recording

 view release on metacpan or  search on metacpan

lib/Net/OpenSSH/More.pm  view on Meta::CPAN

Usage of File::Temp and auto-cleanup to prevent lingering ctl_path cruft.

=item

Ability to manipulate incoming text while streaming the output of commands.

=item

Run perl subroutine refs you write locally but execute remotely.

lib/Net/OpenSSH/More.pm  view on Meta::CPAN

die_on_drop - If, for some reason, the connection drops, just die instead of attempting reconnection.

=item

output_prefix - If given, is what we will tack onto the beginning of any output via diag method.
useful for streaming output to say, a TAP consumer (test) via passing in '# ' as prefix.

=item

debug - Pass in a truthy value to enable certain diag statements I've added in the module and pass -v to ssh.

 view release on metacpan or  search on metacpan

share/fixed_amqp0-8.xml  view on Meta::CPAN

    <!--
======================================================
==       STREAMING
======================================================
-->
  work with streaming content

<doc>
  The stream class provides methods that support multimedia streaming.
  The stream class uses the following semantics: one message is one
  packet of data; delivery is unacknowleged and unreliable; the consumer
  can specify quality of service parameters that the server can try to
  adhere to; lower-priority messages may be discarded in favour of high
  priority messages.

share/fixed_amqp0-8.xml  view on Meta::CPAN

  <field name = "consume rate" type = "long">
    transfer rate in octets/second
    <doc>
      Specifies a desired transfer rate in octets per second. This is
      usually determined by the application that uses the streaming
      data.  A value of zero means "no limit", i.e. as rapidly as
      possible.
    </doc>
    <doc name = "rule">
      The server MAY ignore the prefetch values and consume rates,

share/fixed_amqp0-8.xml  view on Meta::CPAN

    the queue was declared as private, and ideally, impose no limit
    except as defined by available resources.
  </doc>
  <doc name = "rule">
    Streaming applications SHOULD use different channels to select
    different streaming resolutions. AMQP makes no provision for
    filtering and/or transforming streams except on the basis of
    priority-based selective delivery of individual messages.
  </doc>
  <chassis name = "server" implement = "MUST" />
  <response name = "consume-ok" />

 view release on metacpan or  search on metacpan

lib/Net/Riak/Bucket.pm  view on Meta::CPAN

    my $keys = $bucket->get_keys;
    my $keys = $bucket->get_keys($args);

Return an arrayref of the list of keys for a bucket.

Note for the PBC interface: you will need a separate instance of the client (i.e separate connection) if you want to preform actions on the keys whilst streaming them.

Optionally takes a hashref of named parameters. Supported parameters are:

=over 4

=item stream => 1

Uses key streaming mode to fetch the list of keys, which may be faster for large keyspaces.

=item cb => sub { }

A callback subroutine to be called for each key found (passed in as the only parameter). get_keys() returns nothing in callback mode.

lib/Net/Riak/Bucket.pm  view on Meta::CPAN

Whether to return bucket properties. Defaults to 'true' if no parameters are given.

=item keys => 'true'|'false'|'stream'

Whether to return bucket keys. If set to 'stream', uses key streaming mode, which may be faster for large keyspaces.

=item cb => sub { }

A callback subroutine to be called for each key found (passed in as the only parameter). Implies keys => 'stream'. Keys are omitted from the results hashref in callback mode.

 view release on metacpan or  search on metacpan

lib/Net/Rovio.pm  view on Meta::CPAN

Use Net::Rovio to control your Rovio robot from Perl. Uses basic Rovio API commands.

The Rovio L<http://www.wowwee.com/en/products/tech/telepresence/rovio/rovio> is a
Wi-Fi enabled mobile webcam that lets you view and interact with its environment
through streaming video and audio.

=head1 FUNCTIONS

Functions usually return "OK" upon success, unless otherwise noted per function.

lib/Net/Rovio.pm  view on Meta::CPAN

=back

=head2 $rovio->getdata()

Enables streaming video. Incomplete at this time.

=head2 $rovio->getddns()

Gets the Dynamic DNS settings within the Rovio. Returns

 view release on metacpan or  search on metacpan

lib/Net/SCTP.pm  view on Meta::CPAN

=head1 DESCRIPTION

An SCTP (Stream Control Transport Protocol) module created for Perl using XS
with the Net extension because it is a net module.

SCTP is a streaming protocol of things like UDP and TCP. It is used in new
technologies like LTE for phones. It streams data from multiple or one source
to multiple or one source. If one connection is lost the data is not lost because
it will continue to buffer until it gets the connection back and gets the rest of
the message. It is also backwards compatible with TCP.

 view release on metacpan or  search on metacpan

examples/kwax.sdp  view on Meta::CPAN

v=0
o=- 31177 13 IN IP4 128.223.230.19
s=KWAX Classical Radio (PCM)
i=Live streaming radio from the University of Oregon's own KWAX Classical radio station.
u=http://www.kwax.com/
e=<multicast@lists.uoregon.edu>
p=(541) 346-1758
b=AS:64
t=0 0

 view release on metacpan or  search on metacpan

lib/Net/Server/PSGI.pm  view on Meta::CPAN

        $env->{'psgi.input'}        = $self->{'server'}->{'client'};
        $env->{'psgi.errors'}       = $self->{'server'}->{'log_handle'};
        $env->{'psgi.multithread'}  = 1;
        $env->{'psgi.multiprocess'} = 1;
        $env->{'psgi.nonblocking'}  = 1; # need to make this false if we aren't of a forking type server
        $env->{'psgi.streaming'}    = 1;
        local %ENV;
        $self->process_psgi_request($env);
        alarm(0);
        1;
    };

 view release on metacpan or  search on metacpan

lib/Net/Shoutcast/Admin.pm  view on Meta::CPAN

}


=item source_connected

Returns true if the stream is currently up (a source is connected and streaming
audio to the server)

=cut

sub source_connected {

 view release on metacpan or  search on metacpan

Stream.pm  view on Meta::CPAN

our $VERSION = '0.28';
1;

=head1 NAME

Using Twitter's streaming api.

=head1 SYNOPSIS

  use Net::Twitter::Stream;

Stream.pm  view on Meta::CPAN

a twitter account to connect.

JSON format is only supported. Twitter may depreciate XML.


More details at: http://dev.twitter.com/pages/streaming_api

Options 
  user, pass: required, twitter account user/password
  callback: required, a subroutine called on each received tweet
  

 view release on metacpan or  search on metacpan

t/amqp0-8.xml  view on Meta::CPAN

    <!--
======================================================
==       STREAMING
======================================================
-->
  work with streaming content

<doc>
  The stream class provides methods that support multimedia streaming.
  The stream class uses the following semantics: one message is one
  packet of data; delivery is unacknowleged and unreliable; the consumer
  can specify quality of service parameters that the server can try to
  adhere to; lower-priority messages may be discarded in favour of high
  priority messages.

t/amqp0-8.xml  view on Meta::CPAN

  <field name = "consume rate" type = "long">
    transfer rate in octets/second
    <doc>
      Specifies a desired transfer rate in octets per second. This is
      usually determined by the application that uses the streaming
      data.  A value of zero means "no limit", i.e. as rapidly as
      possible.
    </doc>
    <doc name = "rule">
      The server MAY ignore the prefetch values and consume rates,

t/amqp0-8.xml  view on Meta::CPAN

    the queue was declared as private, and ideally, impose no limit
    except as defined by available resources.
  </doc>
  <doc name = "rule">
    Streaming applications SHOULD use different channels to select
    different streaming resolutions. AMQP makes no provision for
    filtering and/or transforming streams except on the basis of
    priority-based selective delivery of individual messages.
  </doc>
  <chassis name = "server" implement = "MUST" />
  <response name = "consume-ok" />

 view release on metacpan or  search on metacpan

lib/Net/UpYun.pm  view on Meta::CPAN

=item * simple check file exists on remote ,no need  to fetch its content,save bandwidth.

=item * display/compare files checksum(MD5) local and remote.

=item * streaming upload to save memory.

=item * useful utility, like tar/untar to/from upyun on fly.

=item * multi operation and performance requests in parallel.

 view release on metacpan or  search on metacpan

lib/Net/WebSocket.pm  view on Meta::CPAN

Net::WebSocket emphasizes flexibility and lightness rather than the more
monolithic approach in modules like L<Mojolicious>.
Net::WebSocket should support anything
that the WebSocket protocol itself can do, as lightly as possible and without
prejudice as to how you want to do it: extensions, streaming, blocking or
non-blocking I/O, arbitrary HTTP headers, etc. The end result should be a
clean, light implementation that will grow (or shrink!) as your needs
dictate.

=head1 OVERVIEW

lib/Net/WebSocket.pm  view on Meta::CPAN

L<permessage-deflate extension|https://tools.ietf.org/html/rfc7692>.

=item * Additional opcodes: 3-7 and 11-15. You’ll need to subclass
L<Net::WebSocket::Frame> for this, and you will likely want to subclass
L<Net::WebSocket::Parser>.
If you’re using the custom classes for streaming, then you can
also subclass L<Net::WebSocket::Streamer>. See each of those modules for
more information on doing this.

B<THIS IS NOT WELL TESTED.> Proceed with caution, and please file bug
reports as needed. (I personally don’t know of any applications that

 view release on metacpan or  search on metacpan

lib/Net/Wire10.pm  view on Meta::CPAN

# Sends a wire protocol ping
sub ping {
	my $self = shift;

	$self->_check_streaming;
	$self->_check_connected;
	$self->_reset_command_state;
	$self->_reset_timeout($self->{connect_timeout});

	return $self->_execute_command(COMMAND_PING, '', undef);

lib/Net/Wire10.pm  view on Meta::CPAN

sub _check_connected {
	my $self = shift;
	$self->_fatal_error("Not connected") unless defined($self->{socket});
}

# Fail if currently connected to a streaming data reader
sub _check_streaming {
	my $self = shift;
	$self->_vanilla_error("Connection is busy streaming") if $self->{streaming};
}

# Connects to the database server
sub _connect {
	my $self = shift;

lib/Net/Wire10.pm  view on Meta::CPAN

sub _execute_query {
	my $self = shift;
	my $sql = shift;
	my $wantstream = shift;

	$self->_check_streaming;
	$self->_check_connected;
	$self->_reset_command_state;
	$self->_reset_timeout($self->{query_timeout});
	$self->{streaming} = 1 if $wantstream;

	my $iterator = Net::Wire10::Results->new($self);
	$self->{streaming_iterator} = $iterator if $wantstream;

	# The protocol is configured to always use UTF-8 during handskake, to
	# avoid messing with all the local character sets.  Therefore any input
	# string needs to be automatically converted if it is not already UTF-8.
	utf8::upgrade($sql) if defined($sql) and not utf8::is_utf8($sql);

lib/Net/Wire10.pm  view on Meta::CPAN

	}
	if ($macket->{type} == MACKET_RESULT_SET_HEADER) {
		my $pos = MACKET_HEADER_LENGTH;
		$self->_parse_result_set_header_macket($macket, \$pos);
		$self->_retrieve_column_info($iterator);
		$self->_retrieve_results($iterator) unless $self->{streaming};
	}
	if ($macket->{type} == MACKET_OK) {
		$self->_parse_ok_macket($macket, $iterator);
		$self->_detach_results($iterator);
	}

lib/Net/Wire10.pm  view on Meta::CPAN

# Disconnect result set from driver, must only be done after all results have been read
sub _detach_results {
	my $self = shift;
	my $iterator = shift;
	$iterator->{wire}->{streaming_iterator} = undef;
	$iterator->{wire}->{streaming} = 0;
	$iterator->{wire} = undef;
}

# Reads and interprets OK, saving the number of affected rows,
# the insert id, and the server message.  Returns the number of

lib/Net/Wire10.pm  view on Meta::CPAN

}

# Resets the command execution status
sub _reset_command_state {
	my $self = shift;
	# Disconnect streaming iterator.
	$self->_detach_results($self->{streaming_iterator}) if defined($self->{streaming_iterator});
	# Reset internal column counter.
	$self->{no_of_columns} = undef;
	# Reset error state.
	$self->{error} = undef;
	# Reset cancel flag.

lib/Net/Wire10.pm  view on Meta::CPAN

	#       For disconnected result sets, row data could be integrity
	#       checked during query() to simplify error handling for
	#       applications.

	if (defined($wire)) {
		# In streaming mode, fetch a row
		return undef unless $wire->_retrieve_row_data($self);
	}

	# Return unless there is another row available
	return undef if scalar(@{$self->{row_data}}) == 0;

lib/Net/Wire10.pm  view on Meta::CPAN

sub query {
	my $self = shift;
	return $self->_execute(0);
}

# Run the prepared statement and return a result object for streaming.
sub stream {
	my $self = shift;
	return $self->_execute(1);
}

lib/Net/Wire10.pm  view on Meta::CPAN

A result set is returned.  The obtained result set will be live with the driver.  After retrieving the result set, you must traverse all of its rows before you can fire another query.

Use stream() for large result sets, as it has a smaller memory footprint compared to query().  If you want to download data to a disconnected result set, use query().

Note that stream() will lock the driver until the whole result set has been retrieved.  To fetch another set of results while streaming to a live result set, create another driver object.

Also note that if you are using MySQL with the default storage engine, MyISAM, the entire table on the server will be locked for the duration of the live result set, that is until all rows have been retrieved.

=head3 prepare

lib/Net/Wire10.pm  view on Meta::CPAN

All results are spooled before the call returns.

=head3 stream

Execute the prepared statement using the parameters previously set with set_parameter().
As soon as the initial metadata arrives from the database server, the call returns, and the results can be traversed in a streaming fashion.

=head2 Features in the I<Net::Wire10::Results> iterator

A Net::Wire10::Results object is returned when calling query() or stream().  Depending on which was used to execute the SQL, either a disconnected result set or a live (streaming) result set is returned.

=head3 next_array

The next_array() method returns a whole row, with individual field values packed into an array.
C<undef> is returned once all rows has been extracted.

lib/Net/Wire10.pm  view on Meta::CPAN

After calling next_hash(), the row has been consumed.  There is currently no way to rewind and re-read a row, even for a disconnected result set.

=head3 spool

Reads the remaining rows of the result set, in effect turning a streaming result set into a disconnected result set.

=head3 flush

Reads the remaining rows of the result set and discards them.  When done on a live result set, this frees the driver for use.

lib/Net/Wire10.pm  view on Meta::CPAN

  my $selected = $wire->get_no_of_selected_rows;

After consuming a row, the number of available rows will decrease, and get_no_of_selected_rows() will return one less.

Supported only for disconnected result sets, live/streaming result sets are unaware of the total number of records.  A streaming result set can be turned into a disconnected result set using spool(), after which the number of available rows becomes k...

=head3 get_insert_id

MySQL and Drizzle has the ability to choose unique key values automatically, by enabling auto_increment for a column.  When this happens, the newly assigned id value for the last inserted row is stored in this attribute.

=head3 get_warning_count

After a query, this returns the number of warnings generated on the server.  If the query is streaming to a live result set, an additional warning count is available after the last row of data has been read.

=head2 Features in the I<Net::Wire10::Error> object

After an error has occurred, call $wire->C<get_error_info()> to retrieve an Error object containing details of the problem.

lib/Net/Wire10.pm  view on Meta::CPAN

There is also a purely SQL-driven interface to prepared statements, using the PREPARE, EXECUTE and DEALLOCATE PREPARE commands.  The SQL-driven interface does not have the same performance benefits as the protocol-level one does.  It can however be u...

There is also a client-side prepared statement interface in the driver, which it is highly recommended to use.

=head3 High-granularity streaming

Streaming data along the way as it is consumed or delivered by the client application can lead to dramatical decreases in memory usage.

Streaming outgoing data can be accomplished with server-side prepared statements, because the wire protocol allows prepared statement parameters to be sent one at a time, and even in chunks.  Chunking data presumably allows you to interleave data to ...

The driver API currently allows client applications to stream incoming data one row at a time.  The highest supported granularity for streaming is one whole row at a time.  Streaming at a higher granularity and interleaving chunks of incoming data is...

Streaming incoming data in a row-by-row fashion is also known in some drivers as "use_result mode".

=head3 Server-side cursors

Cursors provide a way of keeping open, navigating and optionally modifying a result set on the server, rather than having to transfer the entire result set to the client.

MySQL Server supports only a particular class of cursors known as read-only, forward-only cursors.  As the name implies, this kind of cursor cannot be navigated (also called "scrolled") or modified.

The semantics are exactly the same as when streaming incoming data with the L<stream>() call.  With cursors however, the server automatically creates a temporary table behind the scenes from which the data is read, thereby always using extra resource...

There is also a purely SQL-driven interface to cursors, which can be useful inside stored procedures.

Server-side cursors are part of the prepared statement protocol features (see above), and are therefore currently not supported.

 view release on metacpan or  search on metacpan

lib/Net/Inet.pm  view on Meta::CPAN

sslp	1750
swiftnet	1751
lofr-lm	1752
translogic-lm	1753
oracle-em2	1754
ms-streaming	1755
capfast-lmd	1756
cnhrp	1757
tftp-mcast	1758
spss-lm	1759
www-ldap-gw	1760

lib/Net/Inet.pm  view on Meta::CPAN

sslp	1750
swiftnet	1751
lofr-lm	1752
translogic-lm	1753
oracle-em2	1754
ms-streaming	1755
capfast-lmd	1756
cnhrp	1757
tftp-mcast	1758
spss-lm	1759
www-ldap-gw	1760

 view release on metacpan or  search on metacpan

lib/ODG/Record/Discussion.pod  view on Meta::CPAN

=head1 DISCUSSION

This document maintains some thoughts of Record Iterators and Moose.

ODG::Record is designed for efficient streaming, i.e. accessing
one-record-at-a-time. For conventional record iterators, a new row 
object is created for each record, slots are initialized, data are 
filled and types are checked. Not all of this is desirable.

=head1 Object Recycling

 view release on metacpan or  search on metacpan

externals/OPTIMADE/CHANGELOG.md  view on Meta::CPAN

### New features

- **Property definitions** ([#376](https://github.com/Materials-Consortia/OPTIMADE/pull/376)): A new section titled [Property Definitions](https://github.com/Materials-Consortia/OPTIMADE/blob/v1.2.0/optimade.rst#property-definitions) has been added t...
- **Namespace prefixes for definitions** ([#473](https://github.com/Materials-Consortia/OPTIMADE/pull/473)): The mechanism for providers to define custom properties under their own namespace/prefix has been extended to allow implementations to share ...
- **Partial data** ([#467](https://github.com/Materials-Consortia/OPTIMADE/pull/467)): Adds a mechanism and format for streaming, paginating or slicing individual properties within entries.
- **Per entry/property metadata** ([#463](https://github.com/Materials-Consortia/OPTIMADE/pull/463)): Added a mechanism for providing metadata specific to a given entry or property.
- **Files endpoint** ([#360](https://github.com/Materials-Consortia/OPTIMADE/pull/360)): The [`files` entry type](https://github.com/Materials-Consortia/OPTIMADE/blob/v1.2.0/optimade.rst#files-entries) has been added to provide a robust way of linkin...
- **Symmetry operation specification and space group fields** ([#480](https://github.com/Materials-Consortia/OPTIMADE/pull/480), [#405](https://github.com/Materials-Consortia/OPTIMADE/pull/405), [#464](https://github.com/Materials-Consortia/OPTIMADE/...
- **Database licenses** ([#414](https://github.com/Materials-Consortia/OPTIMADE/pull/414),[#497](https://github.com/Materials-Consortia/OPTIMADE/pull/497)): Several fields have been added to programmatically describe the licensing status of data serv...
- **Database metadata field** ([#424](https://github.com/Materials-Consortia/OPTIMADE/pull/424)): Added an additional metadata field `database` for providing a human-readable description of a given database.

 view release on metacpan or  search on metacpan

Changes  view on Meta::CPAN

0.05  2012-10-15
      - OX::Request->mapping should return a hashref, not a hash (minor
        back-compat break)

0.04  2012-09-29
      - support streaming responses

0.03  2012-09-28
      - fix tests on windows (path issue)
      - fix Counter-Improved example not having uri_for available
        (yet_another_anonymo)

 view release on metacpan or  search on metacpan

lib/ObjectDBI.pm  view on Meta::CPAN

package ObjectDBI::Cursor;

=head1 CURSORS

Cursors are there to obtain lists of objects in a 'streaming' (as opposed
to 'buffered') fashion.  When the list of objects is (potentially) too long
to retrieve all at once, you'd use a cursor and iterate through it.

=head2 B<my $cursor = $objectdbi-E<gt>cursor([query], [type]);>