File Coverage

blib/lib/Paws/CloudSearchDomain.pm
Criterion Covered Total %
statement 3 3 100.0
branch n/a
condition n/a
subroutine 1 1 100.0
pod n/a
total 4 4 100.0


line stmt bran cond sub pod time code
1             package Paws::CloudSearchDomain;
2 1     1   4047 use Moose;
  1         3  
  1         9  
3             sub service { 'cloudsearchdomain' }
4             sub version { '2013-01-01' }
5             sub flattened_arrays { 0 }
6             has max_attempts => (is => 'ro', isa => 'Int', default => 5);
7             has retry => (is => 'ro', isa => 'HashRef', default => sub {
8             { base => 'rand', type => 'exponential', growth_factor => 2 }
9             });
10             has retriables => (is => 'ro', isa => 'ArrayRef', default => sub { [
11             ] });
12              
13             with 'Paws::API::Caller', 'Paws::API::EndpointResolver', 'Paws::Net::V4Signature', 'Paws::Net::RestJsonCaller', 'Paws::Net::RestJsonResponse';
14              
15            
16             sub Search {
17             my $self = shift;
18             my $call_object = $self->new_with_coercions('Paws::CloudSearchDomain::Search', @_);
19             return $self->caller->do_call($self, $call_object);
20             }
21             sub Suggest {
22             my $self = shift;
23             my $call_object = $self->new_with_coercions('Paws::CloudSearchDomain::Suggest', @_);
24             return $self->caller->do_call($self, $call_object);
25             }
26             sub UploadDocuments {
27             my $self = shift;
28             my $call_object = $self->new_with_coercions('Paws::CloudSearchDomain::UploadDocuments', @_);
29             return $self->caller->do_call($self, $call_object);
30             }
31            
32              
33              
34             sub operations { qw/Search Suggest UploadDocuments / }
35              
36             1;
37              
38             ### main pod documentation begin ###
39              
40             =head1 NAME
41              
42             Paws::CloudSearchDomain - Perl Interface to AWS Amazon CloudSearch Domain
43              
44             =head1 SYNOPSIS
45              
46             use Paws;
47              
48             my $obj = Paws->service('CloudSearchDomain');
49             my $res = $obj->Method(
50             Arg1 => $val1,
51             Arg2 => [ 'V1', 'V2' ],
52             # if Arg3 is an object, the HashRef will be used as arguments to the constructor
53             # of the arguments type
54             Arg3 => { Att1 => 'Val1' },
55             # if Arg4 is an array of objects, the HashRefs will be passed as arguments to
56             # the constructor of the arguments type
57             Arg4 => [ { Att1 => 'Val1' }, { Att1 => 'Val2' } ],
58             );
59              
60             =head1 DESCRIPTION
61              
62             You use the AmazonCloudSearch2013 API to upload documents to a search
63             domain and search those documents.
64              
65             The endpoints for submitting C<UploadDocuments>, C<Search>, and
66             C<Suggest> requests are domain-specific. To get the endpoints for your
67             domain, use the Amazon CloudSearch configuration service
68             C<DescribeDomains> action. The domain endpoints are also displayed on
69             the domain dashboard in the Amazon CloudSearch console. You submit
70             suggest requests to the search endpoint.
71              
72             For more information, see the Amazon CloudSearch Developer Guide.
73              
74             =head1 METHODS
75              
76             =head2 Search(Query => Str, [Cursor => Str, Expr => Str, Facet => Str, FilterQuery => Str, Highlight => Str, Partial => Bool, QueryOptions => Str, QueryParser => Str, Return => Str, Size => Int, Sort => Str, Start => Int, Stats => Str])
77              
78             Each argument is described in detail in: L<Paws::CloudSearchDomain::Search>
79              
80             Returns: a L<Paws::CloudSearchDomain::SearchResponse> instance
81              
82             Retrieves a list of documents that match the specified search criteria.
83             How you specify the search criteria depends on which query parser you
84             use. Amazon CloudSearch supports four query parsers:
85              
86             =over
87              
88             =item * C<simple>: search all C<text> and C<text-array> fields for the
89             specified string. Search for phrases, individual terms, and prefixes.
90              
91             =item * C<structured>: search specific fields, construct compound
92             queries using Boolean operators, and use advanced features such as term
93             boosting and proximity searching.
94              
95             =item * C<lucene>: specify search criteria using the Apache Lucene
96             query parser syntax.
97              
98             =item * C<dismax>: specify search criteria using the simplified subset
99             of the Apache Lucene query parser syntax defined by the DisMax query
100             parser.
101              
102             =back
103              
104             For more information, see Searching Your Data in the I<Amazon
105             CloudSearch Developer Guide>.
106              
107             The endpoint for submitting C<Search> requests is domain-specific. You
108             submit search requests to a domain's search endpoint. To get the search
109             endpoint for your domain, use the Amazon CloudSearch configuration
110             service C<DescribeDomains> action. A domain's endpoints are also
111             displayed on the domain dashboard in the Amazon CloudSearch console.
112              
113              
114             =head2 Suggest(Query => Str, Suggester => Str, [Size => Int])
115              
116             Each argument is described in detail in: L<Paws::CloudSearchDomain::Suggest>
117              
118             Returns: a L<Paws::CloudSearchDomain::SuggestResponse> instance
119              
120             Retrieves autocomplete suggestions for a partial query string. You can
121             use suggestions enable you to display likely matches before users
122             finish typing. In Amazon CloudSearch, suggestions are based on the
123             contents of a particular text field. When you request suggestions,
124             Amazon CloudSearch finds all of the documents whose values in the
125             suggester field start with the specified query string. The beginning of
126             the field must match the query string to be considered a match.
127              
128             For more information about configuring suggesters and retrieving
129             suggestions, see Getting Suggestions in the I<Amazon CloudSearch
130             Developer Guide>.
131              
132             The endpoint for submitting C<Suggest> requests is domain-specific. You
133             submit suggest requests to a domain's search endpoint. To get the
134             search endpoint for your domain, use the Amazon CloudSearch
135             configuration service C<DescribeDomains> action. A domain's endpoints
136             are also displayed on the domain dashboard in the Amazon CloudSearch
137             console.
138              
139              
140             =head2 UploadDocuments(ContentType => Str, Documents => Str)
141              
142             Each argument is described in detail in: L<Paws::CloudSearchDomain::UploadDocuments>
143              
144             Returns: a L<Paws::CloudSearchDomain::UploadDocumentsResponse> instance
145              
146             Posts a batch of documents to a search domain for indexing. A document
147             batch is a collection of add and delete operations that represent the
148             documents you want to add, update, or delete from your domain. Batches
149             can be described in either JSON or XML. Each item that you want Amazon
150             CloudSearch to return as a search result (such as a product) is
151             represented as a document. Every document has a unique ID and one or
152             more fields that contain the data that you want to search and return in
153             results. Individual documents cannot contain more than 1 MB of data.
154             The entire batch cannot exceed 5 MB. To get the best possible upload
155             performance, group add and delete operations in batches that are close
156             the 5 MB limit. Submitting a large volume of single-document batches
157             can overload a domain's document service.
158              
159             The endpoint for submitting C<UploadDocuments> requests is
160             domain-specific. To get the document endpoint for your domain, use the
161             Amazon CloudSearch configuration service C<DescribeDomains> action. A
162             domain's endpoints are also displayed on the domain dashboard in the
163             Amazon CloudSearch console.
164              
165             For more information about formatting your data for Amazon CloudSearch,
166             see Preparing Your Data in the I<Amazon CloudSearch Developer Guide>.
167             For more information about uploading data for indexing, see Uploading
168             Data in the I<Amazon CloudSearch Developer Guide>.
169              
170              
171              
172              
173             =head1 PAGINATORS
174              
175             Paginator methods are helpers that repetively call methods that return partial results
176              
177              
178              
179              
180             =head1 SEE ALSO
181              
182             This service class forms part of L<Paws>
183              
184             =head1 BUGS and CONTRIBUTIONS
185              
186             The source code is located here: https://github.com/pplu/aws-sdk-perl
187              
188             Please report bugs to: https://github.com/pplu/aws-sdk-perl/issues
189              
190             =cut
191