# -*- coding: UTF-8 -*-
import collections
import copy
import functools
import logging
import threading
from urllib.parse import urlparse
from . import __version__
from .types import IndexType, MetricType, Status
from .check import check_pass_param, is_legal_host, is_legal_port
from .pool import ConnectionPool
from .grpc_handler import GrpcHandler
from .http_handler import HttpHandler
from .exceptions import ParamError, NotConnectError, DeprecatedError
from ..settings import DefaultConfig as config
LOGGER = logging.getLogger(__name__)
def deprecated(func):
@functools.wraps(func)
def inner(*args, **kwargs):
error_str = "Function {} has been deprecated".format(func.__name__)
LOGGER.error(error_str)
raise DeprecatedError(error_str)
return inner
def check_connect(func):
@functools.wraps(func)
def inner(self, *args, **kwargs):
return func(self, *args, **kwargs)
return inner
def _pool_args(**kwargs):
pool_kwargs = dict()
for k, v in kwargs.items():
if k in ("pool_size", "wait_timeout", "handler", "try_connect", "pre_ping"):
pool_kwargs[k] = v
return pool_kwargs
def _set_uri(host, port, uri, handler="GRPC"):
default_port = config.GRPC_PORT if handler == "GRPC" else config.HTTP_PORT
default_uri = config.GRPC_URI if handler == "GRPC" else config.HTTP_URI
uri_prefix = "tcp://" if handler == "GRPC" else "http://"
if host is not None:
_port = port if port is not None else default_port
_host = host
elif port is None:
try:
_uri = urlparse(uri) if uri else urlparse(default_uri)
_host = _uri.hostname
_port = _uri.port
except (AttributeError, ValueError, TypeError) as e:
raise ParamError("uri is illegal: {}".format(e))
else:
raise ParamError("Param is not complete. Please invoke as follow:\n"
"\t(host = ${HOST}, port = ${PORT})\n"
"\t(uri = ${URI})\n")
if not is_legal_host(_host) or not is_legal_port(_port):
raise ParamError("host {} or port {} is illegal".format(_host, _port))
return "{}{}:{}".format(uri_prefix, str(_host), str(_port))
[docs]class Milvus:
def __init__(self, host=None, port=None, handler="GRPC", **kwargs):
self._uri = None
self._status = None
self._connected = False
self._handler = handler
_uri = kwargs.get('uri', None)
pool_uri = _set_uri(host, port, _uri, self._handler)
pool_kwargs = _pool_args(handler=handler, **kwargs)
self._pool = ConnectionPool(pool_uri, **pool_kwargs)
# store extra key-words arguments
self._kw = kwargs
self._hooks = collections.defaultdict()
def __enter__(self):
self._conn = self._pool.fetch()
return self
def __exit__(self, exc_type, exc_val, exc_tb):
self._conn.close()
self._conn = None
def __del__(self):
return self.close()
def _connection(self):
return self._pool.fetch()
[docs] @deprecated
def set_hook(self, **kwargs):
"""
Deprecated
"""
# TODO: may remove it.
if self._stub:
return self._stub.set_hook(**kwargs)
self._hooks.update(kwargs)
@property
def handler(self):
return self._handler
[docs] @deprecated
def connect(self, host=None, port=None, uri=None, timeout=2):
"""
Deprecated
"""
if self.connected() and self._connected:
return Status(message="You have already connected {} !".format(self._uri),
code=Status.CONNECT_FAILED)
if self._stub is None:
self._init(host, port, uri, handler=self._handler)
if self.ping(timeout):
self._status = Status(message="Connected")
self._connected = True
return self._status
[docs] @deprecated
def connected(self):
"""
Deprecated
"""
return True if self._status and self._status.OK() else False
[docs] @deprecated
def disconnect(self):
"""
Deprecated
"""
pass
[docs] def close(self):
"""
Close client instance
"""
self._pool = None
[docs] def client_version(self):
"""
Returns the version of the client.
:return: Version of the client.
:rtype: (str)
"""
return __version__
[docs] def server_status(self, timeout=10):
"""
Returns the status of the Milvus server.
:return:
Status: Whether the operation is successful.
str : Status of the Milvus server.
:rtype: (Status, str)
"""
return self._cmd("status", timeout)
[docs] def server_version(self, timeout=10):
"""
Returns the version of the Milvus server.
:return:
Status: Whether the operation is successful.
str : Version of the Milvus server.
:rtype: (Status, str)
"""
return self._cmd("version", timeout)
@check_connect
def _cmd(self, cmd, timeout=10):
check_pass_param(cmd=cmd)
with self._connection() as handler:
return handler._cmd(cmd, timeout)
[docs] @check_connect
def create_collection(self, param, timeout=10):
"""
Creates a collection.
:type param: dict
:param param: Information needed to create a collection.
`param={'collection_name': 'name',
'dimension': 16,
'index_file_size': 1024 (default)，
'metric_type': Metric_type.L2 (default)
}`
:param timeout: Timeout in seconds.
:type timeout: double
:return: Whether the operation is successful.
:rtype: Status
"""
if not isinstance(param, dict):
raise ParamError('Param type incorrect, expect {} but get {} instead'
.format(type(dict), type(param)))
collection_param = copy.deepcopy(param)
if 'collection_name' not in collection_param:
raise ParamError('collection_name is required')
collection_name = collection_param["collection_name"]
collection_param.pop('collection_name')
if 'dimension' not in collection_param:
raise ParamError('dimension is required')
dim = collection_param["dimension"]
collection_param.pop("dimension")
index_file_size = collection_param.get('index_file_size', 1024)
collection_param.pop('index_file_size', None)
metric_type = collection_param.get('metric_type', MetricType.L2)
collection_param.pop('metric_type', None)
check_pass_param(collection_name=collection_name, dimension=dim, index_file_size=index_file_size,
metric_type=metric_type)
with self._connection() as handler:
return handler.create_collection(collection_name, dim, index_file_size, metric_type, collection_param)
[docs] @check_connect
def has_collection(self, collection_name, timeout=10):
"""
Checks whether a collection exists.
:param collection_name: Name of the collection to check.
:type collection_name: str
:param timeout: Timeout in seconds.
:type timeout: int
:return:
Status: indicate whether the operation is successful.
bool if given collection_name exists
"""
check_pass_param(collection_name=collection_name)
with self._connection() as handler:
return handler.has_collection(collection_name, timeout)
[docs] @check_connect
def get_collection_info(self, collection_name, timeout=10):
"""
Returns information of a collection.
:type collection_name: str
:param collection_name: Name of the collection to describe.
:returns: (Status, table_schema)
Status: indicate if query is successful
table_schema: return when operation is successful
:rtype: (Status, TableSchema)
"""
check_pass_param(collection_name=collection_name)
with self._connection() as handler:
return handler.describe_collection(collection_name, timeout)
[docs] @check_connect
def count_entities(self, collection_name, timeout=10):
"""
Returns the number of vectors in a collection.
:type collection_name: str
:param collection_name: target table name.
:returns:
Status: indicate if operation is successful
res: int, table row count
"""
check_pass_param(collection_name=collection_name)
with self._connection() as handler:
return handler.count_collection(collection_name, timeout)
[docs] @check_connect
def list_collections(self, timeout=10):
"""
Returns collection list.
:return:
Status: indicate if this operation is successful
collections: list of collection names, return when operation
is successful
:rtype:
(Status, list[str])
"""
with self._connection() as handler:
return handler.show_collections(timeout)
[docs] @check_connect
def get_collection_stats(self, collection_name, timeout=10):
"""
Returns collection statistics information
:return:
Status: indicate if this operation is successful
statistics: statistics information
:rtype:
(Status, dict)
"""
check_pass_param(collection_name=collection_name)
with self._connection() as handler:
return handler.show_collection_info(collection_name, timeout)
[docs] @check_connect
def load_collection(self, collection_name, timeout=None):
"""
Loads a collection for caching.
:type collection_name: str
:param collection_name: collection to load
:returns:
Status: indicate if invoke is successful
"""
check_pass_param(collection_name=collection_name)
with self._connection() as handler:
return handler.preload_collection(collection_name, timeout)
[docs] @check_connect
def drop_collection(self, collection_name, timeout=10):
"""
Deletes a collection by name.
:type collection_name: str
:param collection_name: Name of the collection being deleted
:return: Status, indicate if operation is successful
:rtype: Status
"""
check_pass_param(collection_name=collection_name)
with self._connection() as handler:
return handler.drop_collection(collection_name, timeout)
[docs] @check_connect
def insert(self, collection_name, records, ids=None, partition_tag=None, params=None, timeout=None, **kwargs):
"""
Insert vectors to a collection.
:param ids: list of id
:type ids: list[int]
:type collection_name: str
:param collection_name: Name of the collection to insert vectors to.
:type records: list[list[float]]
`example records: [[1.2345],[1.2345]]`
`OR using Prepare.records`
:param records: List of vectors to insert.
:type partition_tag: str or None.
If partition_tag is None, vectors will be inserted to the collection rather than partitions.
:param partition_tag: Tag of a partition.
:returns:
Status: Whether vectors are inserted successfully.
ids: IDs of the inserted vectors.
:rtype: (Status, list(int))
"""
if kwargs.get("insert_param", None) is not None:
with self._connection() as handler:
return handler.insert(None, None, timeout=timeout, **kwargs)
check_pass_param(collection_name=collection_name, records=records)
partition_tag is not None and check_pass_param(partition_tag=partition_tag)
if ids is not None:
check_pass_param(ids=ids)
if len(records) != len(ids):
raise ParamError("length of vectors do not match that of ids")
params = params or dict()
if not isinstance(params, dict):
raise ParamError("Params must be a dictionary type")
with self._connection() as handler:
return handler.insert(collection_name, records, ids, partition_tag, params, timeout, **kwargs)
[docs] @check_connect
def get_entity_by_id(self, collection_name, ids, timeout=None):
"""
Returns raw vectors according to ids.
:param collection_name: Name of the collection
:type collection_name: str
:param ids: list of vector id
:type ids: list
:returns:
Status: indicate if invoke is successful
"""
check_pass_param(collection_name=collection_name, ids=ids)
with self._connection() as handler:
return handler.get_vectors_by_ids(collection_name, ids, timeout=timeout)
[docs] @check_connect
def list_id_in_segment(self, collection_name, segment_name, timeout=None):
check_pass_param(collection_name=collection_name)
check_pass_param(collection_name=segment_name)
with self._connection() as handler:
return handler.get_vector_ids(collection_name, segment_name, timeout)
[docs] @check_connect
def create_index(self, collection_name, index_type=None, params=None, timeout=None, **kwargs):
"""
Creates index for a collection.
:param collection_name: Collection used to create index.
:type collection_name: str
:param index: index params
:type index: dict
index_param can be None
`example (default) param={'index_type': IndexType.FLAT,
'nlist': 16384}`
:param timeout: grpc request timeout.
if `timeout` = -1, method invoke a synchronous call, waiting util grpc response
else method invoke a asynchronous call, timeout work here
:type timeout: int
:return: Whether the operation is successful.
"""
_index_type = IndexType.FLAT if index_type is None else index_type
check_pass_param(collection_name=collection_name, index_type=_index_type)
params = params or dict()
if not isinstance(params, dict):
raise ParamError("Params must be a dictionary type")
with self._connection() as handler:
return handler.create_index(collection_name, _index_type, params, timeout, **kwargs)
[docs] @check_connect
def get_index_info(self, collection_name, timeout=10):
"""
Show index information of a collection.
:type collection_name: str
:param collection_name: table name been queried
:returns:
Status: Whether the operation is successful.
IndexSchema:
"""
check_pass_param(collection_name=collection_name)
with self._connection() as handler:
return handler.describe_index(collection_name, timeout)
[docs] @check_connect
def drop_index(self, collection_name, timeout=10):
"""
Removes an index.
:param collection_name: target collection name.
:type collection_name: str
:return:
Status: Whether the operation is successful.
：:rtype: Status
"""
check_pass_param(collection_name=collection_name)
with self._connection() as handler:
return handler.drop_index(collection_name, timeout)
[docs] @check_connect
def create_partition(self, collection_name, partition_tag, timeout=10):
"""
create a partition for a collection.
:param collection_name: Name of the collection.
:type collection_name: str
:param partition_name: Name of the partition.
:type partition_name: str
:param partition_tag: Name of the partition tag.
:type partition_tag: str
:param timeout: time waiting for response.
:type timeout: int
:return:
Status: Whether the operation is successful.
"""
check_pass_param(collection_name=collection_name, partition_tag=partition_tag)
with self._connection() as handler:
return handler.create_partition(collection_name, partition_tag, timeout)
[docs] @check_connect
def has_partition(self, collection_name, partition_tag):
"""
Check if specified partition exists.
:param collection_name: target table name.
:type collection_name: str
:param partition_tag: partition tag.
:type partition_tag: str
:return:
Status: Whether the operation is successful.
exists: If specified partition exists
"""
check_pass_param(collection_name=collection_name, partition_tag=partition_tag)
with self._connection() as handler:
return handler.has_partition(collection_name, partition_tag)
[docs] @check_connect
def list_partitions(self, collection_name, timeout=10):
"""
Show all partitions in a collection.
:param collection_name: target table name.
:type collection_name: str
:param timeout: time waiting for response.
:type timeout: int
:return:
Status: Whether the operation is successful.
partition_list:
"""
check_pass_param(collection_name=collection_name)
with self._connection() as handler:
return handler.show_partitions(collection_name, timeout)
[docs] @check_connect
def drop_partition(self, collection_name, partition_tag, timeout=10):
"""
Deletes a partition in a collection.
:param collection_name: Collection name.
:type collection_name: str
:param partition_tag: Partition name.
:type partition_tag: str
:param timeout: time waiting for response.
:type timeout: int
:return:
Status: Whether the operation is successful.
"""
check_pass_param(collection_name=collection_name, partition_tag=partition_tag)
with self._connection() as handler:
return handler.drop_partition(collection_name, partition_tag, timeout)
[docs] @check_connect
def search(self, collection_name, top_k, query_records, partition_tags=None, params=None, timeout=None, **kwargs):
"""
Search vectors in a collection.
:param collection_name: Name of the collection.
:type collection_name: str
:param top_k: number of vertors which is most similar with query vectors
:type top_k: int
:param nprobe: cell number of probe
:type nprobe: int
:param query_records: vectors to query
:type query_records: list[list[float32]]
:param partition_tags: tags to search
:type partition_tags: list
:return
Status: Whether the operation is successful.
result: query result
:rtype: (Status, TopKQueryResult)
"""
check_pass_param(collection_name=collection_name, topk=top_k, records=query_records)
if partition_tags is not None:
check_pass_param(partition_tag_array=partition_tags)
params = dict() if params is None else params
if not isinstance(params, dict):
raise ParamError("Params must be a dictionary type")
with self._connection() as handler:
return handler.search(collection_name, top_k, query_records, partition_tags, params, timeout, **kwargs)
[docs] @check_connect
def search_in_segment(self, collection_name, file_ids, query_records, top_k, params=None, timeout=None, **kwargs):
"""
Searches for vectors in specific segments of a collection.
The Milvus server stores vector data into multiple files. Searching for vectors in specific files is a
method used in Mishards. Obtain more detail about Mishards, see
<a href="https://github.com/milvus-io/milvus/tree/master/shards">
:type collection_name: str
:param collection_name: table name been queried
:type file_ids: list[str] or list[int]
:param file_ids: Specified files id array
:type query_records: list[list[float]]
:param query_records: all vectors going to be queried
:param query_ranges: Optional ranges for conditional search.
If not specified, search in the whole table
:type top_k: int
:param top_k: how many similar vectors will be searched
:returns:
Status: indicate if query is successful
results: query result
:rtype: (Status, TopKQueryResult)
"""
check_pass_param(collection_name=collection_name, topk=top_k, records=query_records, ids=file_ids)
params = dict() if params is None else params
if not isinstance(params, dict):
raise ParamError("Params must be a dictionary type")
with self._connection() as handler:
return handler.search_in_files(collection_name, file_ids,
query_records, top_k, params, timeout, **kwargs)
[docs] @check_connect
def delete_entity_by_id(self, collection_name, id_array, timeout=None):
"""
Deletes vectors in a collection by vector ID.
:param collection_name: Name of the collection.
:type collection_name: str
:param id_array: list of vector id
:type id_array: list[int]
:return:
Status: Whether the operation is successful.
"""
check_pass_param(collection_name=collection_name, ids=id_array)
with self._connection() as handler:
return handler.delete_by_id(collection_name, id_array, timeout)
[docs] @check_connect
def flush(self, collection_name_array=None, timeout=None, **kwargs):
"""
Flushes vector data in one collection or multiple collections to disk.
:type collection_name_array: list
:param collection_name: Name of one or multiple collections to flush.
"""
if collection_name_array in (None, []):
with self._connection() as handler:
return handler.flush([], timeout)
if not isinstance(collection_name_array, list):
raise ParamError("Collection name array must be type of list")
if len(collection_name_array) <= 0:
raise ParamError("Collection name array is not allowed to be empty")
for name in collection_name_array:
check_pass_param(collection_name=name)
with self._connection() as handler:
return handler.flush(collection_name_array, timeout, **kwargs)
[docs] @check_connect
def compact(self, collection_name, timeout=None, **kwargs):
"""
Compacts segments in a collection. This function is recommended after deleting vectors.
:type collection_name: str
:param collection_name: Name of the collections to compact.
"""
check_pass_param(collection_name=collection_name)
with self._connection() as handler:
return handler.compact(collection_name, timeout, **kwargs)
[docs] def get_config(self, parent_key, child_key):
"""
Gets Milvus configurations.
"""
cmd = "get_config {}.{}".format(parent_key, child_key)
return self._cmd(cmd)
[docs] def set_config(self, parent_key, child_key, value):
"""
Sets Milvus configurations.
"""
cmd = "set_config {}.{} {}".format(parent_key, child_key, value)
return self._cmd(cmd)


| XML Search Feed | |
|---|---|
|
| Search Feed Input | ||||||||||||||||||||||||||||||||||||||||||||
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
|
| Cached Web Page Input | ||||||||||||||||
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
|
| The Output |
|---|
|
Gigablast allows you to receive the search results in a number of formats useful for interfacing to your program. Here is an example of the XML feed. We plan for the output of the precise search engine to have all the same output fields as the fast search engine, but for now it is missing some because the code was significantly overhauled for the new search algorithm and we are still putting pieces back together. output only from precise search engine (&precise=1) is in greenoutput only from fast search engine (&precise=0) is in red The XML reply has the following format (but without the comments): <?xml version="1.0" encoding="utf-8" ?> # It consists of one, and only one, response. <response> # the current time on the search engine <currentTimeUTC>1373944554</currentTimeUTC> # How long in milliseconds to compute these results? <responseTimeMS>2373</responseTimeMS> # Total number of documents in the collection being searched. <docsInCollection>2060245584</docsInCollection> # If any error was received in processing the request, it will be here. <error><![CDATA[Out of memory]]></error> # The numeric code of the error, if any, goes here. If no error, this is 0. <errno>32790</errno> # Total number of search results for the query. This is an exact count # for the precise search engine, but an approximation for the fast search # engine. <hits>4838158</hits> # This is "1" if more results are available after these, "0" if not. <moreResultsFollow>1</moreResultsFollow> # If present and value is 1, some words in the query was censored for # adult content. Only used if &ff=1 is specified. (Family Filter) <queryCensored>1</queryCensored> # If present, the value is the number of results that were censored for # adult content. Only used if &ff=1 is specified. (Family Filter) <resultsCensored>3</resultsCensored> # If this tag is present, it will hold an alternate spelling recommendation # for the query. The &spell=1 parameter must be present in the query url, # however, for you to get a spelling recommendation back. <spell><![CDATA[nose]]></spell> # If this tag is present, it contains the list of query words that were # ignored as individual words, but not necessarily as part of a phrase <ignoredWords><![CDATA[the in of]]></ignoredWords> # The list of search results, each one enclosed in a <result> tag. <result> # Each result has a title. This may be empty if none was found on the page. <title><![CDATA[My Homepage]]></title> # Each result has a summary. This may be empty. The summary is generated # so as to contain the query terms if possible. <sum><![CDATA[All about my interests and hobbies]]></sum> # If this result is categorized under the DMOZ Directory, data about each # category it is in will be enclosed in a <dmoz> tag. <dmoz> # The category ID number of this category. <dmozCatId>172</dmozCatId> # The path of this category in the directory. <dmozCat><![CDATA[Health: Dentistry]]></dmozCat> # Title of this result as listed in the directory. <dmozTitle><![CDATA[My Homepage]]></dmozTitle> # Description of this page as listed in the directory. <dmozDesc><![CDATA[A Dentist's Home Page]]></dmozDesc> </dmoz> # If the directory is being given along with the results, this is the number of # stars given to this page based on its quality. <stars>3</stars> # Each result may have a sequence of <display> tags if the feed input # contained a dt parameter. This allows you to extract # information contained in meta tags in the content of each search result. # To obtain the contents of the author meta tag, you would need to pass in # dt=author. <display name="author"><![CDATA[Contents of the meta author tag]]></display> # Each result has a URL. This should never be empty. <url><![CDATA[http://www.mydomain.com/mypage.html]]></url> # The size of the page in kilobytes. Accurate to the tenth of a kilobyte. <size>5.6</size> # The time the page was LAST indexed. It may not have been indexed in a # long time if the page's content has not changed. The time is expressed # in seconds since the epoch. (Jan 1, 1969) <indexed>1064367311</indexed> # The time the page was FIRST indexed. Expressed in UTC # in seconds since the epoch. (Jan 1, 1969) <firstIndexedDateUTC>1064367311</firstIndexedDate> # The time the page was published. <pubDate>1058477041</pubDate> # if the pubDate above is really the last modified date then this is 1. # This is taken from the HTTP reply of the web server when downloading # the page. The time is expressed in seconds since the epoch (Jan 1, 1969) # and is in UTC. <isModDate>1</isModDate> # The assigned docid for this page. This number is unique and used # internally by Gigablast to identify this page. It is used to retrieve the # "cached copy" of the page. <docId>65990704587</docId> # The site the result is from. A site is a measure of control. <site><![CDATA[mydomain.com/]]></site> # When it was last spidered, a UTC timestamp <spidered>1064367311</docId> # When doing site clustering, this tag will be present if the result is # from the same hostname as a previous result for the same query. It # indicates that you might want to indent the result. Any further results # from this same hostname will be stripped from the feed. <clustered>1</clustered> # This is a standard HTTP MIME content classification of the result. It is # not present if the page is text/html. Otherwise, it will be one of the # following: text/plain # text/xml # application/pdf # application/msword # application/vnd.ms-excel # application/mspowerpoint # application/postscript <contentType><![CDATA[text/plain]]></contentType> # This is the language the page was detected as. <language><![CDATA[English]]></language> # The character set this page was originally encoded in. <charset><![CDATA[utf-8]]></charset> </result> <result> ... </result> ... </response> |
| Key | |
| a | Error used by an add or delete collection operation. |
| i | Error used by an inject (or delete) operation. |
| s | Error used by a search operation. |
| C error codes | ||
| 1 | Operation not permitted | a - Did not have permission in the working dir to create/delete the collection subdir. |
| 2 | No such file or directory | a - When creating the subdir for the collection in the working dir, a directory component in pathname does not exist or is a dangling symbolic link. |
| 5 | Input/output error | a,i,s - There was an error writing or reading data to or from the disk, most likely due to a hardware failure. |
| 9 | Bad file descriptor | a,i,s - Read or write on a bad file descriptor. This should not happen. |
| 12 | Cannot allocate memory | a,i,s - Out of memory. |
| 13 | Permission denied | a,i - The working directory, or its parent does not allow write permission. |
| 17 | File exists | a - The collection subdir already exists in the working dir. |
| 28 | No space left on device | a,i - There is no room on the drive to write data because the drive is full, or the user's disk quota is exhausted. |
| 105 | No buffer space available | a - Collection name limit of 16 is exceeded. |
| Gigablast error codes | ||
| 32769 | Try doing it again | a,i,s - Resources temporarily unavailable. |
| 32770 | Add denied, db is closing | i - Gigablast is shutting down, so the inject failed. |
| 32771 | Record not found | i - When looking up old document for injected URL it was not found when it should have been. This is due to data corruption. |
| 32775 | Could not get the default tagdb record | i - The default tagdb*.xml (ruleset) file was not found. Make sure that the ruleset used by tagdb or by the Url Filters page for this url is present in the working dir. |
| 32777 | Something is wrong with reply | i - Received bad internal reply. You should never see this error. |
| 32784 | Bad engineer | a - Collection name being added contains an illegal character, or an empty name was provided, or the name is more than 64 characters. i - No URL was provided, or URL has no hostname. Or provided URL is currently being injected. Or 500 injects are currently in progress. |
| 32785 | Can not add because db is closing | i - Gigablast is shutting down, so the inject failed. |
| 32789 | Buf too small | i - Injected URL was longer than 1024 characters. Or the injected document was too big to fit in memory, so consider increasing |
| 32792 | Bad cached document | i,s - A cached document was corrupt on disk. |
| 32793 | Document is missing query terms | s - A document in the search results did not contain all the query terms. |
| 32795 | No docid | i - No docids were available to inject the URL. The database has reached its limit. |
| 32797 | No udp slots available | a,i,s - There was a shortage of sockets, please try again. |
| 32811 | Doc bad content type | i - The URL's file extension is not recognized as an indexable file type. |
| 32842 | Query too big | s - Query was too long. |
| 32843 | Query was truncated | s - Query was truncated. |
| 32844 | Boolean query has too many operands | s - Query has too many operands. |
| 32849 | Bad mime | i - The provided HTTP mime (if the hasmime flag was set) was not present or illegal. |
| 32855 | DNS sent an unknown response code | i - DNS error |
| 32856 | DNS refused to talk | i - DNS error |
| 32858 | DNS timed out | i - DNS error |
| 32863 | No collection record | a,i,s - Referenced collection does not exist. |
| 32864 | Shutting down the server | i - Gigablast is shutting down, so the inject failed. |


THEME
Dribbling and Passing through Cones (U6-9 Technical)
DESCRIPTION OF PRACTISE
A Practise designed to encourage players dribbling and passing
ORGANISATION
4 to 5 cones setup to dribble through
3 cones with a ball on top of the middle cone
3-4 players per group Setup as many groups are required
Players dribble through cones and try knock their football off the middle cone.
Players must strike ball before they pass the end cone
Player must retrieve their football and bring back to the team mate
KEY FACTORS
Dribbling, soft touches, keep ball close, head up
Passing, pace and accuracy
NOTES
Progress the competition between teams, change distance of passing depending on ability of players.
Create a competition between teams by awarding 2 points to anyone who dribbles through the cones without
the ball hitting the cones. Award 2 points if they pass the ball through the cones. Award 5 points if
they knock the ball off the middle cone.


Mi5
Floating widgets with target tracking, Video Play, 2D Animation
❮
❯
© Iting Shih. All rights reserved. | Photos by
Fotogrph
| Design by
TEMPLATED
.


@helper.form(action = routes.Application.sign, 'enctype -> "multipart/form-data") { }
Select a contract:


--- layout: post status: publish published: true title: Bonne Chance, Murton & Gallagher! Get bent, E-Pat! author: display_name: Andy login: Andy email<EMAIL_ADDRESS>url: '' author_login: Andy author_email<EMAIL_ADDRESS>excerpt: |- In a move designed to keep all bugeaters in Nebraska and California, the Cubs have shipped Sean Gallagher, Matt Murton, Eric Patterson, and Josh Donaldson off to Oakland for Rich Harden and Chad Gaudin. Either someone at MLB.com is a Photoshop champ, or Gallagher's "bring me a bowl of Life Cereal" grin was no one-time fluke occurrence. But Life is not the only thing Gallagher likes to ingest, apparently. The Sun-Times' website reports that "Derrek Lee spotted a bug in his locker Saturday in St. Louis, [and] Gallagher ate it for an undisclosed sum of cash -- to the disgust and delight of Lee and teammate Reed Johnson." However, despite Gallagher's billygoat-esque stance toward eating, I wish he was still a Cub. I don't feel that his numbers this year reflected his potential as a pitcher (3-4 4.45 era); some of his starts did feature anemic offense from the Cubs. I'll leave the Matt Murton farewell post up to Corey, but Daft Funk of Thunder Matt's Saloon had this Lebowski pastiche for Murton's departure: wordpress_id: 122 wordpress_url: http://ivyenvy.wordpress.com/?p=122 date: '2008-07-09 15:38:36 +0000' date_gmt: '2008-07-09 20:38:36 +0000' categories: - The Cubs tags: - Bugeaters - Chad Gaudin - Eric Patterson - Jay Johnstone - Josh Donaldson - Matt Murton - Rich Harden - Sean Gallagher - The Big Lebowski - Thunder Matt's Saloon comments: - id: 68 author: Kurt Tucker author_email<EMAIL_ADDRESS>author_url: '' date: '2008-07-09 16:11:29 +0000' date_gmt: '2008-07-09 21:11:29 +0000' content: I just can't wait to see Murton's red mane under that green cap. Merry Christmas Oakland! ---
In a move designed to keep all bugeaters in Nebraska and California, the Cubs have shipped Sean Gallagher, Matt Murton, Eric Patterson, and Josh Donaldson off to Oakland for Rich Harden and Chad Gaudin.
Either someone at MLB.com is a Photoshop champ, or Gallagher's "bring me a bowl of Life Cereal" grin was no one-time fluke occurrence. But Life is not the only thing Gallagher likes to ingest, apparently. The Sun-Times' website reports that "Derrek Lee spotted a bug in his locker Saturday in St. Louis, [and] Gallagher ate it for an undisclosed sum of cash -- to the disgust and delight of Lee and teammate Reed Johnson." However, despite Gallagher's billygoat-esque stance toward eating, I wish he was still a Cub. I don't feel that his numbers this year reflected his potential as a pitcher (3-4 4.45 era); some of his starts did feature anemic offense from the Cubs.
I'll leave the Matt Murton farewell post up to Corey, but Daft Funk of Thunder Matt's Saloon had this Lebowski pastiche for Murton's departure:
"Thunder Matt was a good baseball player and a good man. He was one of us. He was a man who loved the outfield...and bowling, and as an outfielder he explored the right fields of the National League, from Wrigley to Coors Field and...up to...Pittsburgh. He was traded, like so many young men of his generation, he was traded before his time. In your wisdom, Lord, you took him, as you took so many bright flowering young men at Khe Sanh, at Langdok, at Hill 364. These young men gave their lives. And so would Thunder Matt. Thunder, who loved baseball. And so, Matthew Henry "Thunder" Murton, in accordance with what we think your dying wishes might well have been, we commit your final mortal remains to the bosom of Oakland, which you loved so well."
P.S. Thunder Matt's Saloon also made me aware of the existence of this incredible baseball card:
(Johnstone was a career .267 hitter during his 23 season MLB career. He played for the Cubs from '82-'84, and he also had keen fashion sensibilities.)