 Innovation Brigade has many
years of experience in the creation of websites which make content management straight forward
and efficient, allowing you to focus on running your business rather than concern yourself with
technical details.
Our mission is to provide our clients with powerful tools which enable them to effectively
manage their corporate identity and marketing message via their website without involving
external support or consultants. From the basic „business card online“ to the presentation of
your company identity to a website with complex and frequently updated content - Innovation
Brigade creates solutions which match your requirements. Our solutions are based on proven and
thoroughly tested open-source systems which are configured, adapted and extended according to
the given project requirements.
We operate across all industries and place great importance on the robustness and scalability of
the systems we deploy. Whether you administer only a few pages or thousands of content elements
from various media types; Innovation Brigade will create a solution for you which exactly
matches your specifications. You will be able to administer your website quickly, flexibly and
accurately without having to resort to expensive external support.
eCommerce
eCommerce has become a sales channel that noone can ignore. If you wish to compete
effectively in today's market, your online sales channel can not be neglected.
Regardless of whether you are an eCommerce pure-play, a manufacturer of specialized goods or a
traditional trading business, the online sales channel has developed into an important factor
for the increase of brand awareness, customer loyalty and customer satisfaction.
Through increased efficiency in order processing as well as the continuous and effective
optimization of the buying experience, an efficiently implemented eCommerce presence can be an
important factor for cost savings and customer loyalty. The 24/7 availability as well as the
improved customer service are an essential component in the improvement of customer
satisfaction.
Innovation Brigade creates specialized solutions which transform your eCommerce strategy into a
competitive advantage. Effectively implemented eCommerce allows you to increase your revenue,
improve long term customer loyalty, acquire new customers and increase your brand awareness.
Our platform provides you with a large number real-time reporting capabilities which help you
discover your most profitable customers and products, your inventory levels and other data which
is relevant to the performance of your business. In addition to this, our eCommerce platform
features a call-center mode which allows you to enter customer order which are received via
phone or fax.
Innovation Brigade eCommerce is designed to be flexible and extensible. This design philosophy
extends throughout the system and translates into quick implementation times as well as low
maintenance and development costs. Whether you wish to add specialized product views, new
payment methods, automatically import product data or export order data, by leveraging our
architecture, Innovation Brigade eCommerce allows you to implement such changes quickly and with
high quality.
Discover the capabilities of Innovation Brigade eCommerce and ask us to set up a demo
environment for you in which you can discover the power and flexibility of our system. If you
have complex needs and wish to have them analyzed by us, contact us with your requirements and
we will analyze their impact and generate an implementation quote for you. Alternatively, we are
also available to travel to your offices and hold a detailed workshop during which we analyze
your requirements together with you and work to arrive at a project implementation plan.
Development
When evaluating software for a particular purpose, it is often the case that existing solutions
almost cover your specific needs. It is this „almost“ which can cause significant
problems and costs when implementing new software in your organization, since it may require
altering your business processes in order to be compatible with the way the software process
requires.
In any complex organization, existing business processes are the result of conscious and
unconscious optimization processes over time. Since every company works slightly differently,
standard software can only suit your business processes to a certain degree.
The goal must thus be to close this gap between desire and reality. Rather than changing your
business processes, Innovation Brigade offers you development services which adapts software to
your specific needs.
Whether you need a custom application which is entirely specific to you or changes to an
existing solution in order to adapt it your needs, Innovation Brigade has the know-how and
skills to provide you with a system which works according to your specific requirements.  Utilize the efficiency
you have acquired over the years and inspire your customers with improved services.
Consulting
Software development is a complex and expensive process, requiring specific skills and
experience. Based on the expertise we have acquired over the years, we are available to assist
our customers development efforts in a number of technology areas.
Whether you require full project lifecycle management or specific technology know-how which you
don't have in house, Innovation Brigade can complement your team in a number of areas and
provide expert knowledge for the duration of your project or project phase.
Innovation Brigade can provide proven expertise in the following areas:
- LAMP (Linux, Apache, MySql, PHP) software stack or any portion thereof
- Open source CMS systems (Wordpress, Joomla, Drupal, Zikula) as well as portability issues
- Java programming frameworks
- Database design and optimalization
- Big Data (Hadoop, HBase)
- Project Management
- eCommerce implementation and best practices
- Outsourcing
We have proven experience in all of the above areas. In the field of outsourcing, we partner with
several proven Eastern European development firms and use their technical expertise to provide
complete project lifecycle coverage to deliver quality solutions at a reduced cost.


Please type in your username as well as the email address when you register. As soon as you click the Send Email button, an email with your password will be sent to your email address.


Welcome Daniel Tomasevich,
Logout
Account
Update
Calendar
Inbox
Help
Search for your Professor
GatorDater Professor Lookup


All files
97.34%
Statements
659/677
97.91%
Branches
234/239
93.09%
Functions
175/188
97.2%
Lines
625/643
File
Statements
Branches
Functions
Lines
controllers
98.11%
364/371
98.5%
131/133
95.41%
104/109
98%
343/350
helpers
100%
13/13
100%
0/0
100%
3/3
100%
13/13
models
96.25%
282/293
97.17%
103/106
89.47%
68/76
96.07%
269/280


|
|||||||||||
| PREV NEXT | FRAMES NO FRAMES |
| Packages that use Query | |
| org.apache.lucene.index.memory | High-performance single-document main memory Apache Lucene fulltext search index. |
| org.apache.lucene.queryParser | A simple query parser implemented with JavaCC. |
| org.apache.lucene.queryParser.analyzing | |
| org.apache.lucene.queryParser.precedence | |
| org.apache.lucene.queryParser.surround.query | This package contains SrndQuery and its subclasses. |
| org.apache.lucene.search | Search over indices. |
| org.apache.lucene.search.highlight | The highlight package contains classes to provide "keyword in context" features typically used to highlight search terms in the text of results pages. |
| org.apache.lucene.search.regex | Regular expression Query. |
| org.apache.lucene.search.similar | Document similarity query generators. |
| org.apache.lucene.search.spans | The calculus of spans. |
| org.apache.lucene.wordnet | This package uses synonyms defined by WordNet to build a Lucene index storing them, which in turn can be used for query expansion. |
| Uses of Query in org.apache.lucene.index.memory |
| Methods in org.apache.lucene.index.memory with parameters of type Query | |
float |
MemoryIndex.search(Query query)
Convenience method that efficiently returns the relevance score by matching this index against the given Lucene query expression. |
| Uses of Query in org.apache.lucene.queryParser |
| Methods in org.apache.lucene.queryParser that return Query | |
Query |
QueryParser.parse(String query)
Parses a query string, returning a Query . |
protected Query |
QueryParser.getFieldQuery(String field,
String queryText)
|
protected Query |
QueryParser.getFieldQuery(String field,
String queryText,
int slop)
Base implementation delegates to QueryParser.getFieldQuery(String,String) . |
protected Query |
QueryParser.getRangeQuery(String field,
String part1,
String part2,
boolean inclusive)
|
protected Query |
QueryParser.getBooleanQuery(Vector clauses)
Factory method for generating query, given a set of clauses. |
protected Query |
QueryParser.getBooleanQuery(Vector clauses,
boolean disableCoord)
Factory method for generating query, given a set of clauses. |
protected Query |
QueryParser.getWildcardQuery(String field,
String termStr)
Factory method for generating a query. |
protected Query |
QueryParser.getPrefixQuery(String field,
String termStr)
Factory method for generating a query (similar to QueryParser.getWildcardQuery(java.lang.String, java.lang.String) ). |
protected Query |
QueryParser.getFuzzyQuery(String field,
String termStr,
float minSimilarity)
Factory method for generating a query (similar to QueryParser.getWildcardQuery(java.lang.String, java.lang.String) ). |
Query |
QueryParser.Query(String field)
|
Query |
QueryParser.Clause(String field)
|
Query |
QueryParser.Term(String field)
|
protected Query |
MultiFieldQueryParser.getFieldQuery(String field,
String queryText,
int slop)
|
protected Query |
MultiFieldQueryParser.getFieldQuery(String field,
String queryText)
|
protected Query |
MultiFieldQueryParser.getFuzzyQuery(String field,
String termStr,
float minSimilarity)
|
protected Query |
MultiFieldQueryParser.getPrefixQuery(String field,
String termStr)
|
protected Query |
MultiFieldQueryParser.getWildcardQuery(String field,
String termStr)
|
protected Query |
MultiFieldQueryParser.getRangeQuery(String field,
String part1,
String part2,
boolean inclusive)
|
static Query |
MultiFieldQueryParser.parse(String[] queries,
String[] fields,
Analyzer analyzer)
Parses a query which searches on the fields specified. |
static Query |
MultiFieldQueryParser.parse(String query,
String[] fields,
BooleanClause.Occur[] flags,
Analyzer analyzer)
Parses a query, searching on the fields specified. |
static Query |
MultiFieldQueryParser.parse(String[] queries,
String[] fields,
BooleanClause.Occur[] flags,
Analyzer analyzer)
Parses a query, searching on the fields specified. |
| Methods in org.apache.lucene.queryParser with parameters of type Query | |
protected void |
QueryParser.addClause(Vector clauses,
int conj,
int mods,
Query q)
|
| Uses of Query in org.apache.lucene.queryParser.analyzing |
| Methods in org.apache.lucene.queryParser.analyzing that return Query | |
protected Query |
AnalyzingQueryParser.getWildcardQuery(String field,
String termStr)
Called when parser parses an input term token that contains one or more wildcard characters (? and *), but is not a prefix term token (one that has just a single * character at the end) |
protected Query |
AnalyzingQueryParser.getPrefixQuery(String field,
String termStr)
Called when parser parses an input term token that uses prefix notation; that is, contains a single '*' wildcard character as its last character. |
protected Query |
AnalyzingQueryParser.getFuzzyQuery(String field,
String termStr,
float minSimilarity)
Called when parser parses an input term token that has the fuzzy suffix (~) appended. |
protected Query |
AnalyzingQueryParser.getRangeQuery(String field,
String part1,
String part2,
boolean inclusive)
Overrides super class, by passing terms through analyzer. |
| Uses of Query in org.apache.lucene.queryParser.precedence |
| Methods in org.apache.lucene.queryParser.precedence that return Query | |
Query |
PrecedenceQueryParser.parse(String expression)
Parses a query string, returning a Query . |
protected Query |
PrecedenceQueryParser.getFieldQuery(String field,
String queryText)
|
protected Query |
PrecedenceQueryParser.getFieldQuery(String field,
String queryText,
int slop)
Base implementation delegates to PrecedenceQueryParser.getFieldQuery(String,String) . |
protected Query |
PrecedenceQueryParser.getRangeQuery(String field,
String part1,
String part2,
boolean inclusive)
|
protected Query |
PrecedenceQueryParser.getBooleanQuery(Vector clauses)
Factory method for generating query, given a set of clauses. |
protected Query |
PrecedenceQueryParser.getBooleanQuery(Vector clauses,
boolean disableCoord)
Factory method for generating query, given a set of clauses. |
protected Query |
PrecedenceQueryParser.getWildcardQuery(String field,
String termStr)
Factory method for generating a query. |
protected Query |
PrecedenceQueryParser.getPrefixQuery(String field,
String termStr)
Factory method for generating a query (similar to PrecedenceQueryParser.getWildcardQuery(java.lang.String, java.lang.String) ). |
protected Query |
PrecedenceQueryParser.getFuzzyQuery(String field,
String termStr,
float minSimilarity)
Factory method for generating a query (similar to PrecedenceQueryParser.getWildcardQuery(java.lang.String, java.lang.String) ). |
Query |
PrecedenceQueryParser.Query(String field)
|
Query |
PrecedenceQueryParser.andExpression(String field)
|
Query |
PrecedenceQueryParser.Clause(String field)
|
Query |
PrecedenceQueryParser.Term(String field)
|
| Methods in org.apache.lucene.queryParser.precedence with parameters of type Query | |
protected void |
PrecedenceQueryParser.addClause(Vector clauses,
int conj,
int modifier,
Query q)
|
| Uses of Query in org.apache.lucene.queryParser.surround.query |
| Fields in org.apache.lucene.queryParser.surround.query declared as Query | |
static Query |
SrndQuery.theEmptyLcnQuery
|
| Methods in org.apache.lucene.queryParser.surround.query that return Query | |
Query |
FieldsQuery.makeLuceneQueryNoBoost(BasicQueryFactory qf)
|
Query |
FieldsQuery.makeLuceneQueryFieldNoBoost(String fieldName,
BasicQueryFactory qf)
|
Query |
SrndQuery.makeLuceneQueryField(String fieldName,
BasicQueryFactory qf)
|
abstract Query |
SrndQuery.makeLuceneQueryFieldNoBoost(String fieldName,
BasicQueryFactory qf)
|
Query |
AndQuery.makeLuceneQueryFieldNoBoost(String fieldName,
BasicQueryFactory qf)
|
Query |
NotQuery.makeLuceneQueryFieldNoBoost(String fieldName,
BasicQueryFactory qf)
|
Query |
DistanceQuery.makeLuceneQueryFieldNoBoost(String fieldName,
BasicQueryFactory qf)
|
Query |
DistanceQuery.getSpanNearQuery(IndexReader reader,
String fieldName,
float boost,
BasicQueryFactory qf)
|
Query |
OrQuery.makeLuceneQueryFieldNoBoost(String fieldName,
BasicQueryFactory qf)
|
Query |
SimpleTerm.makeLuceneQueryFieldNoBoost(String fieldName,
BasicQueryFactory qf)
|
| Methods in org.apache.lucene.queryParser.surround.query with parameters of type Query | |
void |
SpanNearClauseFactory.addSpanNearQuery(Query q)
|
| Uses of Query in org.apache.lucene.search |
| Subclasses of Query in org.apache.lucene.search | |
class |
BooleanQuery
A Query that matches documents matching boolean combinations of other queries, e.g. |
class |
ConstantScoreQuery
A query that wraps a filter and simply returns a constant score equal to the query boost for every document in the filter. |
class |
ConstantScoreRangeQuery
A range query that returns a constant score equal to its boost for all documents in the range. |
class |
DisjunctionMaxQuery
A query that generates the union of the documents produced by its subqueries, and that scores each document as the maximum score for that document produced by any subquery plus a tie breaking increment for any additional matching subqueries. |
class |
FilteredQuery
A query that applies a filter to the results of another query. |
class |
FuzzyQuery
Implements the fuzzy search query. |
class |
MatchAllDocsQuery
A query that matches all documents. |
class |
MultiPhraseQuery
MultiPhraseQuery is a generalized version of PhraseQuery, with an added method MultiPhraseQuery.add(Term[]) . |
class |
MultiTermQuery
A Query that matches documents containing a subset of terms provided
by a FilteredTermEnum enumeration. |
class |
PhraseQuery
A Query that matches documents containing a particular sequence of terms. |
class |
PrefixQuery
A Query that matches documents containing terms with a specified prefix. |
class |
RangeQuery
A Query that matches documents within an exclusive range. |
class |
TermQuery
A Query that matches documents containing a term. |
class |
WildcardQuery
Implements the wildcard search query. |
| Methods in org.apache.lucene.search that return Query | |
Query |
IndexSearcher.rewrite(Query original)
|
Query |
ParallelMultiSearcher.rewrite(Query original)
|
Query |
BooleanClause.getQuery()
|
Query |
MultiSearcher.rewrite(Query original)
|
Query |
BooleanQuery.rewrite(IndexReader reader)
|
Query |
Query.rewrite(IndexReader reader)
Expert: called to re-write queries into primitive queries. |
Query |
Query.combine(Query[] queries)
Expert: called when re-writing queries under MultiSearcher. |
static Query |
Query.mergeBooleanQueries(Query[] queries)
Expert: merges the clauses of a set of BooleanQuery's into a single BooleanQuery. |
Query |
Searchable.rewrite(Query query)
Expert: called to re-write queries into primitive queries. |
Query |
ConstantScoreRangeQuery.rewrite(IndexReader reader)
|
Query |
FilteredQuery.rewrite(IndexReader reader)
Rewrites the wrapped query. |
Query |
FilteredQuery.getQuery()
|
Query |
MultiPhraseQuery.rewrite(IndexReader reader)
|
Query |
PrefixQuery.rewrite(IndexReader reader)
|
Query |
RangeQuery.rewrite(IndexReader reader)
|
abstract Query |
Searcher.rewrite(Query query)
|
Query |
DisjunctionMaxQuery.rewrite(IndexReader reader)
Optimize our representation and our subqueries representations |
Query |
FuzzyQuery.rewrite(IndexReader reader)
|
Query |
ConstantScoreQuery.rewrite(IndexReader reader)
|
Query |
ConstantScoreQuery.ConstantWeight.getQuery()
|
Query |
MultiTermQuery.rewrite(IndexReader reader)
|
Query |
RemoteSearchable.rewrite(Query original)
|
Query |
Weight.getQuery()
The query that this concerns. |
| Methods in org.apache.lucene.search with parameters of type Query | |
Query |
IndexSearcher.rewrite(Query original)
|
Query |
ParallelMultiSearcher.rewrite(Query original)
|
void |
BooleanClause.setQuery(Query query)
|
Query |
MultiSearcher.rewrite(Query original)
|
protected Weight |
MultiSearcher.createWeight(Query original)
Create weight in multiple index scenario. |
void |
BooleanQuery.add(Query query,
BooleanClause.Occur occur)
Adds a clause to a boolean query. |
Query |
Query.combine(Query[] queries)
Expert: called when re-writing queries under MultiSearcher. |
static Query |
Query.mergeBooleanQueries(Query[] queries)
Expert: merges the clauses of a set of BooleanQuery's into a single BooleanQuery. |
Query |
Searchable.rewrite(Query query)
Expert: called to re-write queries into primitive queries. |
Hits |
Searcher.search(Query query)
Returns the documents matching query . |
Hits |
Searcher.search(Query query,
Filter filter)
Returns the documents matching query and
filter . |
Hits |
Searcher.search(Query query,
Sort sort)
Returns documents matching query sorted by
sort . |
Hits |
Searcher.search(Query query,
Filter filter,
Sort sort)
Returns documents matching query and filter ,
sorted by sort . |
TopFieldDocs |
Searcher.search(Query query,
Filter filter,
int n,
Sort sort)
Expert: Low-level search implementation with arbitrary sorting. |
void |
Searcher.search(Query query,
HitCollector results)
Lower-level search API. |
void |
Searcher.search(Query query,
Filter filter,
HitCollector results)
Lower-level search API. |
TopDocs |
Searcher.search(Query query,
Filter filter,
int n)
Expert: Low-level search implementation. |
Explanation |
Searcher.explain(Query query,
int doc)
Returns an Explanation that describes how doc scored against
query . |
protected Weight |
Searcher.createWeight(Query query)
creates a weight for query |
abstract Query |
Searcher.rewrite(Query query)
|
void |
DisjunctionMaxQuery.add(Query query)
Add a subquery to this disjunction |
Query |
RemoteSearchable.rewrite(Query original)
|
| Constructors in org.apache.lucene.search with parameters of type Query | |
BooleanClause(Query query,
BooleanClause.Occur occur)
Constructs a BooleanClause. |
|
QueryFilter(Query query)
Constructs a filter which only matches documents matching query . |
|
FilteredQuery(Query query,
Filter filter)
Constructs a new query which applies a filter to the results of the original query. |
| Uses of Query in org.apache.lucene.search.highlight |
| Methods in org.apache.lucene.search.highlight with parameters of type Query | |
static WeightedTerm[] |
QueryTermExtractor.getTerms(Query query)
Extracts all terms texts of a given Query into an array of WeightedTerms |
static WeightedTerm[] |
QueryTermExtractor.getIdfWeightedTerms(Query query,
IndexReader reader,
String fieldName)
Extracts all terms texts of a given Query into an array of WeightedTerms |
static WeightedTerm[] |
QueryTermExtractor.getTerms(Query query,
boolean prohibited,
String fieldName)
Extracts all terms texts of a given Query into an array of WeightedTerms |
static WeightedTerm[] |
QueryTermExtractor.getTerms(Query query,
boolean prohibited)
Extracts all terms texts of a given Query into an array of WeightedTerms |
| Constructors in org.apache.lucene.search.highlight with parameters of type Query | |
QueryScorer(Query query)
|
|
QueryScorer(Query query,
String fieldName)
|
|
QueryScorer(Query query,
IndexReader reader,
String fieldName)
|
| Uses of Query in org.apache.lucene.search.regex |
| Subclasses of Query in org.apache.lucene.search.regex | |
class |
RegexQuery
Implements the regular expression term search query. |
class |
SpanRegexQuery
A SpanQuery version of RegexQuery allowing regular expression
queries to be nested within other SpanQuery subclasses. |
| Methods in org.apache.lucene.search.regex that return Query | |
Query |
SpanRegexQuery.rewrite(IndexReader reader)
|
| Uses of Query in org.apache.lucene.search.similar |
| Methods in org.apache.lucene.search.similar that return Query | |
Query |
MoreLikeThis.like(int docNum)
Return a query that will return docs like the passed lucene document ID. |
Query |
MoreLikeThis.like(File f)
Return a query that will return docs like the passed file. |
Query |
MoreLikeThis.like(URL u)
Return a query that will return docs like the passed URL. |
Query |
MoreLikeThis.like(InputStream is)
Return a query that will return docs like the passed stream. |
Query |
MoreLikeThis.like(Reader r)
Return a query that will return docs like the passed Reader. |
static Query |
SimilarityQueries.formSimilarQuery(String body,
Analyzer a,
String field,
Set stop)
Simple similarity query generators. |
| Uses of Query in org.apache.lucene.search.spans |
| Subclasses of Query in org.apache.lucene.search.spans | |
class |
SpanFirstQuery
Matches spans near the beginning of a field. |
class |
SpanNearQuery
Matches spans which are near one another. |
class |
SpanNotQuery
Removes matches which overlap with another SpanQuery. |
class |
SpanOrQuery
Matches the union of its clauses. |
class |
SpanQuery
Base class for span-based queries. |
class |
SpanTermQuery
Matches spans containing a term. |
| Methods in org.apache.lucene.search.spans that return Query | |
Query |
SpanNearQuery.rewrite(IndexReader reader)
|
Query |
SpanOrQuery.rewrite(IndexReader reader)
|
Query |
SpanNotQuery.rewrite(IndexReader reader)
|
Query |
SpanFirstQuery.rewrite(IndexReader reader)
|
| Uses of Query in org.apache.lucene.wordnet |
| Methods in org.apache.lucene.wordnet that return Query | |
static Query |
SynExpand.expand(String query,
Searcher syns,
Analyzer a,
String field,
float boost)
Perform synonym expansion on a query. |
static Query |
SynLookup.expand(String query,
Searcher syns,
Analyzer a,
String field,
float boost)
Perform synonym expansion on a query. |
|
|||||||||||
| PREV NEXT | FRAMES NO FRAMES |


--- layout: archive title: Zulip Chat Archive permalink: /stream/144837-PR-reviews/topic/.23734.20free.20ring.html ---
@Mario Carneiro May I please pick your brain for a little while? I just pushed to this branch... and I'm not sure if things should be refactored...
Please look at this line https://github.com/leanprover-community/mathlib/blob/a7a2d682c3705f6142a1fa94a9eabebcf90103e5/src/ring_theory/free_comm_ring.lean#L165
I prove that free_comm_ring
is equivalent to mv_polynomial
(but I don't show that it is a natural transformation :sad:)
And then afterwards, there are two special cases.
Those could be done by composing two equiv's, but I don't know if that is good for "defeq"-purposes or not.
Because we also know that mv_polynomial _ punit
is polynomial _
I was thinking the same thing
the latter two should follow from some other equiv, but maybe it hasn't been proven yet
It's true that there are potential defeq problems with the way we define equivs in terms of other equivs, but that's a rabbit hole that will lead to a lot more code duplication so I'm inclined to only address issues caused by this as they arise
@Mario Carneiro So what shall I do? Leave them as is? Remove them? Redefine them as the composition of two equivs?
redefine as composition, if the other equivs exist
I think Kenny did this because he was hoping to replace mv_polynomial
with free_comm_ring
Ok... there are analogous equivs for free_ring
. But there I can't really do the composition trick.
alternatively, you could show that when A
is a subsingleton free_ring A
is commutative and hence equiv to free_comm_ring A
That might be a good idea.
@Mario Carneiro Do we know that a functor maps an equiv to an equiv?
(And now I mean the category/
version. Not category_theory/
).
@Simon Hudon That's your domain, right?
@Johan Commelin Can you clarify your question please?
We have free_abelian_group
which is a functor. And now I have an equiv between two types... I would like to know that their free abelian groups are also equiv.
I assume free_abelian_group
has a map
function?
It has an instance of functor
Even monad
Lawful?
Yep
import data.equiv.basic variables {α β : Type} {f : Type → Type} [functor f] [is_lawful_functor f] variables (h : α ≃ β) open functor equiv function is_lawful_functor example : f α ≃ f β := { to_fun := map h, inv_fun := map h.symm, left_inv := λ x, by { rw map_map, transitivity id <$> x, { congr, ext a, simp only [id.def, symm_apply_apply, comp_app], }, { simp only [is_lawful_functor.id_map] } }, right_inv := sorry /- same thing -/ }
Ok, but this isn't in mathlib, with some goofy notation?
That's mainly what I was asking...
I would never pick a goofy notation
Well... maybe others did... I still struggle with <$>
and <*>
.
So this should be functor.map_equiv
or something like that?
I just looked. It's not in there. You could put it in data/equiv/functor.lean
or data/equiv/instances.lean
Ok, will probably do that.
Do we know of an equiv between list X
and multiset X
if X
is a subsingleton?
If we do, it will be in multiset.lean
but I doubt it's there
I pushed a bunch of stuff to this PR
There is one annoying sorry left...

I want to sleep now... if others want to take a look. Go ahead.
Also, I proved that equiv
between list and multiset for subsingletons, but it is noncomputable. And in the wrong file.
@Mario Carneiro I'm slowly converging to something that should be ready to merge. The equiv between free_ring X
and free_comm_ring X
for subsingletons is now in place. However, it is noncomputable. Should I separately prove a computable version for pempty
and punit
?
@Chris Hughes @Mario Carneiro In my opinion this PR is now ready for review again. (I'm optimistic that Travis will be happy.)
It doesn't need to be noncomputable. It is coming from this theorem:
noncomputable def subsingleton_equiv [subsingleton α] : list α ≃ multiset α := { to_fun := coe, inv_fun := quot.out, left_inv := λ l, list.ext_le (by { rw [← multiset.coe_card, ← multiset.coe_card], congr' 1, exact quot.out_eq _ }) $ λ n h₁ h₂, subsingleton.elim _ _, right_inv := λ l, quot.out_eq _ }
This generalizes to the basic equiv theorem that quot A R ~= A
when \all x y, R x y -> x = y
. The inverse function is defined by quot.lift
, not quot.out
Aha, let me try that.
@Mario Carneiro Done
Also.. there are 2 instances that make perm
a setoid on list X
One is defined in perm.lean
but only for (X : Type)
. The other is in multiset.lean
and works for arbitrary universes.
In this PR I've sneaked a fix that generalises the instance in perm.lean
and removes the one in multiset.lean
.
Here is a link to the changes that I've stacked on top of Kenny's PR: https://github.com/leanprover-community/mathlib/pull/734/files/379d911cd1050ee7bd94af9735b8f261601dab6f..eccc355ae26283e6f0cb6b6023ff958959414a25
Is there anyone who wants to review this PR? @Mario Carneiro @Reid Barton
{% endraw %}Last updated: Apr 24 2020 at 19:02 UTC


Event Location:
Goldenwest College
15744 Goldenwest Street
Huntington Beach, California
Abstract:
You may not see this in the marketing materials, but the reality is PowerPivot and AS Tabular together provide some powerful options for Data Warehousing professionals. This session is for DW dimensional modeling pros interested in streamlining optimizing the design delivery process for enterprise-quality data marts dimensional semantic models. We'll touch on Agile Lean disciplines, how they can be applied to DW solution delivery. Then we’ll walk through demos of practical applications in the form of PowerPivot POCs prototypes that can be promoted to AS Tabular models and refitted to the finished DW structures once delivered. We’ll focus on key DW challenges and how these technologies and techniques can be used to speed and improve effectiveness of requirements gathering and user testing, optimize sequencing of deliverables, minimize risk of rework and ultimately deliver quality DW solutions successfully.
Speaker(s): Brent Greenwood,
Abstract:
The cloud is here and Hybrid cloud can help you get started and move forward! Cloud computing brings a new paradigm shift in computing and organizations continue to realize the potential cost benefits of running their database applications in the cloud with greater scale and flexibility. Take almost any application scenario, from the largest public websites to small departmental applications, and you will find the vast majority of organizations look to take advantage of cloud computing, the availability of cloud-enabled database systems will be critical to their success. This session looks at the Microsoft vision of relational database management systems in the context of cloud computing. It is a hybrid IT vision that gains leverage from the industry-standard Microsoft SQL Server technology set and makes it available across the spectrum of deployment approaches organizations can take today.
Speaker(s): Dania Jones,
Abstract:
SQL Server security sound simple. We grant permissions to people and processes that need access to our SQL Server instances and databases, while controlling which data they can access and what actions they can perform. However, behind this simple statement lies much complexity. In practice, it is easy for the novice database administrator to get lost in the hierarchy of principals, securables and permissions that comprise the SQL Server security architecture. The most common result is the path of least resistance, where people end up with "too many privileges." My primary goals are to provide a simple, concise description of how the SQL Server permission hierarchy works, and then demonstrate, step by step, how to implement the "Principle of Least Privilege" in securing SQL Server. I will also mention security-related items that are new to SQL Server 2014.
Speaker(s): Diana Dee,
Abstract:
Performance troubleshooting is detective work. We'll have a lab system being assaulted by PowerShell scripts (to simulate live users), and simulated performance problems like those that can make your on-call cell phone ring too much! Do you think you have what it takes to find these "needle in the haystack" issues and resolve them quickly? This will be a highly interactive session where we will locate the rogue queries together, work through solutions, implement them and measure the results. In this episode we'll focus primarily on improper indexing as a common underlying problem and all will walk away with much better troubleshooting skills and an upgraded knowledge of performance tuning!
Speaker(s): Jim Murphy,
Abstract:
You always have more report requests than you can possibly fulfill. Wouldn’t it be great if you could speed up the generation of reports? Templates can streamline the life cycle of a report for the whole team. In this session, you’ll learn how templates in your tool belt can help you efficiently gather requirements, quickly design mock-ups, and standardize the look and feel of your SSRS reports. Reports don’t stop changing once they’re released into production, and some reports are phased out over time. Wouldn’t it be great to have a way to keep track of the changes a report takes on in production over time? We’ll talk about how to keep track of change requests, how to analyze the utilization of existing reports, and how to track changes in users for the reports in production.
Speaker(s): Mickey Stuewe,
Abstract:
Query optimizers are highly complex pieces of software, which even after 40 years of research, still face several technical challenges in some fundamental areas. As a result, there may be cases when even after you've provided the query optimizer with all the information it needs, you still don’t get an efficient execution plan for your queries. This session will show you the current challenges and limitations of query optimizers in general and the SQL Server query optimizer in particular, along with solutions or workarounds to avoid each of these problems.
Speaker(s): Benjamin Nevarez,
Abstract:
SQL Azure, Robots, and Twitter! In an ongoing battle our two finch robots DEV (represents developers) and DBA (represents DBAs) will compete against each other. You the audience will help determine the winner of the finch robot race by voting real time on twitter. Participants will leave with an understanding of how leverage SQL Azure to collect data, how robots can help children of all ages learn programming concepts and most importantly which finch robot will reign supreme… the DBA or Developer
Speaker(s): Jeff Renz,
Abstract:
Parameter sniffing is a good thing: it is used by the Query Optimizer to produce an execution plan tailored to the current parameters of a query. However, due to the way that the plan cache stores these plans in memory, sometimes can also be a performance problem. This session will show you how parameter sniffing works and in which cases could be a problem. How to diagnose and troubleshoot parameter sniffing problems and their solutions will be discussed as well. The session will also include details on how the Query Optimizer uses the histogram and density components of the statistics object and some other advanced topics.
Speaker(s): Benjamin Nevarez,
Abstract:
Throughout the past year, we have effectively used PowerPivot, Data Explorer, and Power View to map, evaluate, and measure our ETL processes. In this session, you will learn how PowerPivot can be a key component in verifying data quality. You will also see how Data Explorer can help you shape data for test harnesses and test plans. Finally, you will see how Power View in Excel 2013 can be used to easily share results of ETL projects, especially during the development process.
Speaker(s): Steve Hughes,
Abstract:
This session will provide an introduction to Master Data Management (MDM). We explore the basic concepts, types of MDM solution, and the basics for a successful MDM Implementation. With a working definition in hand, we'll discuss strategies for beginning a successful MDM pilot in your organization and look at some of the pitfalls to avoid. We'll wrap the business discussion up with some tips for selecting the right domains to solve and some tips for managing the politics of MDM. After we've set the stage for what, how and why you need MDM, we'll take a brief look at SQL Server MDS through the Excel add-in and talk about the Architecture of MDS.
Speaker(s): John McAllister,
Abstract:
One dirty little secret of Business Intelligence is that relational databases just haven’t been fast enough to support ad hoc analysis with response times that end users expect. Column store indexes change all of that. Come learn how to build a lean BI solution or supercharge your existing system with minimal effort.
Speaker(s): Robert Hatton,
Abstract:
Performance troubleshooting is detective work. We'll have a lab system being assaulted by PowerShell scripts (to simulate live users), and simulated performance problems like those that can make your on-call cell phone ring too much! Do you think you have what it takes to find these "needle in the haystack" issues and resolve them quickly? This will be a highly interactive session where we will locate the rogue queries together, work through solutions, implement them and measure the results. In this episode we'll focus primarily on poor TSQL coding as a common underlying problem and all will walk away with much better troubleshooting skills and an upgraded knowledge of performance tuning!
Speaker(s): Jim Murphy,
Abstract:
Join Thomas LaRock and Karen Lopez for valuable interviewing tips from both sides of the desk. Based on Tom's blog posts of 10 Things I Hate About Interviewing You and 10 Things I Hate About Interviewing With You, this session will be packed with valuable insight and tips to help you sail through your next job interview
Speaker(s): Karen Lopez,
Abstract:
SQL Server 2012 adds to the Master Data Services (MDS) platform by expanding table-level integration (staging), improving the web UI, providing an Excel add-in, and adding to the services layer. But many organizations have not yet begun to leverage the full potential. This session helps you better understand the Master Data Management (MDM) and MDS by exploring 4 key features in depth. While diving deeply into the new Excel add-in, MDM Hierarchies, MDM Business Rules, and Staging you will gain a much deeper understanding of MDS. The talk will be interspersed with tips and best practices for how start an MDM project in your organization.
Speaker(s): John McAllister,
Abstract:
A highly interactive and popular session where attendees evaluate the options and best practices of common and advanced design issues, such as: * Natural vs. Surrogate keys * NULL/NOTNULL * Classwords and other Naming Standards * Varchar Minimums *the CLOUD * Who Calls the Shots and Who Does What? ...and others. Bring your votes, your debates, and your opinions.
Speaker(s): Karen Lopez,
Abstract:
Often times, a database developer needs to test the data under different scenarios. There are many ways to do that, and some of them involve using TFS and other expensive tools. However, the often-overlooked way to create unit tests and even to automate the data lifecycle is always under the DB developer's finger tips and involves using SSIS and jobs agent for the test automation. The session will provide live hands on examples.
Speaker(s): Virginia Mushkatbat,
Abstract:
SQL Server 14 is continuing to expand on the in memory database features that were first introduced in SQL Server 2012. During this session we will explore the new in memory database tables which were developed under the code name project hekaton. During this presentation the scope of the feature will be discussed as well as reviewing the use cases and best practices for using in memory database tables and when the in memory database tables shouldn’t be used.
Speaker(s): Denny Cherry,
Abstract:
Does this sound like you? You were just given access to SSRS and you want to make a report. Or, you're a DBA and could use a daily report. Either way, I've got your back! You will learn everything you need to know to get that first report out the door quickly and how to tweak it once it’s deployed. We’ll even look at the differences between building a report in BIDS (Business Intelligence Development Studio) and Report Builder 3.0. We’ll use SSRS (SQL Server Reporting Services) 2012. The query makes no difference, this time it's all about the output.
Speaker(s): Tamera Clark,
Abstract:
The deployment process is frustrating; an object is missing, an object is deployed in the wrong order or the incorrect version. Each database is made up of a lot of objects in different environments. When you create an object like a table or stored procedure, you need to get this object deployed into each environment. Together we will discover how to separate each object for proper order deployment while releasing only objects which have changed. Deployments can cause you trouble but we will provide a reliable deployment and version control process.
Speaker(s): Thomas Norman,
Abstract:
Got Powershell? In today's budget tight organizations they want technical administrators to do more with less. If you're a DBA and you're NOT using Powershell, you could be missing out on the milk. In this session, we'll go beyond the simple get commands and learn how to put those results into useful tools like monitoring SQL jobs, disk space, service accounts and put those into a database for future analysis. Learn how to use the true POWER in Powershell.
Speaker(s): Andrew Nakamura,
Abstract:
Microsoft has announced that our next version of SQL Server will be SQL Server 2014. SQL Server 2012 had some major upgrades in AlwaysOn Availability Groups, ColumnStore Indexes, and Resource Governor. SQL 2014 takes those features to the next level and introduces a whole lot more! Rebuild Indexes and Statistics by Partition? Yes! A new Optimizer/Cardinality Estimator that you can choose for your Queries? Yes! Hekaton in memory data tables that exist separate to the buffer pool and use HASH indexes instead of B-TREE? YES! Plus SSD Buffer Pool Extensions, Read-Write ColumnStore Indexes and much more!
Speaker(s): Bradley Ball,
Abstract:
When you are analyzing your database servers, how do you quantify performance gains or losses? After you've made a change, do you wait for your users to tell you if things are better or worse? Do you implement every “best practice” based on an author’s popularity? Join Tim M. Hidalgo for a presentation on the why, how and “what then…” of baselining and the benefits of making informed decisions.
Speaker(s): Tim Hidalgo,
Abstract:
Great database performance starts with great database design. During the database design process it is important to select your datatypes wisely. The wrong choices will often lead to wasted space, increased response times, and less stability. Additionally you run the risk of having your design not scale as well as it should. Leave this session armed with the knowledge you need to help your databases perform at their peak efficiency.
Speaker(s): Thomas LaRock,
Abstract:
This session will cover the following aspects of Power BI • Architecture overview of Power BI • The Data Steward Experience • The Analyst Experience
Speaker(s): Lakshmi Randall,
Abstract:
Window functions are an underused feature in T-SQL. These functions can help you solve complex business problems such as running totals and ranking. If you have never used these functions or are looking to solve ranking and aggregate types of calculations without using GROUP BY, join us for a demo filled session on SQL window functions.
Speaker(s): Steve Hughes,
Abstract:
Have you ever taken over a server or better yet an entire environment? Just recently I changed jobs knowing nothing about their databases except what I could learn from the interview process. I walk in knowing there are going to be issues but where do I start? What is most important, what can wait? How can I get a picture of the systems? Are there any tools to help me? Let’s put our heads together, let’s see what you would do, then I will let you know what I have begun to do.
Speaker(s): Thomas Norman,
Abstract:
Do you dread handing your T-SQL over for code review?  Does the DBA always want to tweak your T-SQL? In this demo heavy session, we’ll take a look at various ways to improve your T-SQL. You’ll learn about formatting T-SQL for readability and why top down design is not the best solution for writing T-SQL. You’ll learn why implicit conversions slow queries down and how to leverage simple techniques for minimizing the performance impact of explicit conversions. By changing some of your T-SQL writing habits you can improve performance of queries from the very beginning.
Speaker(s): Mickey Stuewe,
Abstract:
When it comes to making changes to your production Analysis Services databases, do you simply open the SSAS DB in SQL Server Data Tools (or BIDS) and click through creating the changes? Does this method lead to problems keeping everything in sync and the right changes deployed to the right environment at the right time? Have you, the BI developer, had to fight to get Production access to do your own deployments? If you've answered "yes" to any of these questions, and are in search of a better way, I have the solution! In this demo-heavy session, we will look at five steps to more robust, controllable, and flexible Tabular and Multidimensional SSAS deployments.
Speaker(s): Kerry Tyler,
Abstract:
Turbo charge your SQL Server development with the amazing SQL# CLR library. We will do a quick overview of the SQL# library and then jump into examining a few real world implementations of some of the functions and procedures. Some examples will include string manipulation, file handling, as well as some RegEx usage. There are over 225 procedures and functions, user defined aggregates, and user defined types ... and counting. Come explore some of the interesting problems that SQL# can solve. If you'd like to download and view the CLR library ahead of the presentation, you can get most of the CLR features for free at www.sqlsharp.com.
Speaker(s): David Sumlin,
Abstract:
Indexes are a wonderful thing. We should be using them, and we should be maintaining them. But over time our production databases start to look a little pudgy around the mid-section.  The first step to fixing these problems it so see if you have them, and if you do the second is to set about fixing them. You could be costing yourself CPU cycles, I/Op’s, and space and never even know it.
Speaker(s): Bradley Ball,
Abstract:
Session Abstract: The purpose of this presentation is to provide a practical checklist for planning your Big Data deployment. This session presents guidelines and architectural patterns for big data deployment options such as Cloud Vs. On-premise. My session objectives are: •Provide a comprehensive approach to planning your Big Data Deployment • Illustrate how to bring Big Data into the Enterprise Workflow • Share a few real-world Big data deployment scenarios
Speaker(s): Lakshmi Randall,
Abstract:
ETL (Extract, Transform Load) processes are fundamentally important in any data warehouse environment, and there are many different ways in which to develop the components. In this session I will share the 10 basic principles I follow when developing ETL processes, and also show how the different choices can affect performance. Following these simple guidelines have resulted in many successful projects and happy customers. I'm sure it will work for you too!!
Speaker(s): Martin Schoombee,
Abstract:
This presentation describes the tasks a DBA needs to perform to do a great job. Formal training classes and certifications only take you so far; this session talks from experience about everything from preventive maintenance to planning to scaling to communication. Great for beginner to intermediate DBAs, as well as Developers who think this is a direction in which they might want to move.
Speaker(s): Jeffrey Garbus,
Abstract:
One of the biggest issues in database performance centers around storage. It’s also one of the hardest places to troubleshoot performance issues because storage engineers and database administrators often do not speak the same language. In this session, we’ll be looking at storage from both the database and storage perspectives. We’ll be digging into LUNs, HBAs, the fabric, as well as RAID Groups. In addition to theory, we’ll be looking at an actual EMC SAN so that we can translate what we see in the Storage Array with what we see on the actual server.
Speaker(s): Denny Cherry,
Abstract:
A session focused on ramping you up on what Hadoop is, how its works and what it's capable of. We will also look at what Hadoop 2.0 and YARN brings to the table and some future projects in the Hadoop space to keep an eye on.
Speaker(s): Joe Rossi,
Abstract:
Learn all you wanted to know about index design but were afraid to ask. This session focuses on physical index structures as well as how the server chooses indexes. Note: Join optimization is a separate session
Speaker(s): Jeffrey Garbus,
Abstract:
Slowly Changing Dimensions form an integral part of any Data Warehouse environment, and there are many different factors that will determine the flexibility, scalability and effectiveness of the dimensional structure. The first part of this session takes a look at all the different design elements and considerations of SCD's. We'll look at whether it is feasible to create a snowflake, how to deal with relationships between dimensions as well as 1:1 and many:many relationships with fact tables. Afterwards, we will walk through a practical and effective method (with code) to load SCD's with T-SQL.
 In this session, we will explore some advanced spatial analysis techniques, including clustering, binning, and the basic use of spatial statistics. We will then discuss several options for visualizing the results in SQL Server Reporting Services and PowerPivot. Get ready to go beyond bars and bubble charts!
Speaker(s): Jason Horner,
Abstract:
This session will cover the following aspects of Power BI • The IT Pro experience • Practical solutions with Power BI
Speaker(s): Lakshmi Randall,
Abstract:
In the past, High Availability and Disaster Recovery (HADR) had many limitations. Clustering and Mirroring are great, but the mirror/secondary database is not very usable since it is not online. Finally, AlwaysOn solves this limitation by merging both multi-node Clustering and mirroring. AlwaysOn also allows the secondary database to remain ONLINE, so we can use it for reporting purposes without resorting to a Snapshot! Come see this lively session with extensive demos of setting up, configuring and testing AlwaysOn. We'll also test automatic fail-over using a real web app to see how well this feature works.
Speaker(s): Jim Murphy,
This is a list of speakers from the XML Guidebook records. The details and URLs were valid at the time of the event.
Contact: http://www.benjaminnevarez.com/
Benjamin Nevarez is a SQL Server MVP and independent consultant based in Los Angeles, California who specializes in SQL Server query tuning and optimization. He is the author of “SQL Server 2014 Query Tuning Optimization”, “Inside the SQL Server Query Optimizer” and has contributed to other SQL Server books including “SQL Server 2012 Internals”. Benjamin has also been a speaker at many SQL Server conferences, including the PASS Summit, SQL Server Connections and SQLBits.
LinkedIn: https://www.linkedin.com/in/johnbmcallister/
Contact: http://www.profisee.com
John McAllister co-founded Stratature, an Independent MDM software vendor, in 2001. Following Microsoft’s acquisition of Stratature in 2007 John served as Group Program Manager for MDS and oversaw the incorporation of MDM into SQL Server. John now serves as the Regional Sales Director for Profisee, Inc. which provides enterprise-class MDM Solutions built on top of Microsoft’s MDS offering. John has worked with 100’s of organizations around the world in all phases of MDM projects.
Contact: http://mask-me.net
Virginia Mushkatblat is currently a founder of Hush-Hush, a data masking company. She wrote her first computer program at the age of 14 and has been in technology ever since, progressively rising through the ranks and trying on different hats including database architecture, development, security and operations. She has worked for Startups and Fortune 100 companies in finance, entertainment, e-commerce, internet advertisement, manufacturing, and communications industries and dealt with both heavily transactional and BI applications.She holds B.S. and Masters Degrees in Engineering and in Computer Science, originated a couple of patents, and currently teaches databases and multimedia to graduating seniors in CSUN, her Alma Mater.
Diana Dee has been a Microsoft Certified Trainer since 1996. Since 2005, she has specialized in training and consulting on SQL Server administration, Transact-SQL querying, and database design. Diana lives in Huntington Beach with her husband and two Labrador retrievers. Diana is one of the authors of TribalSQL (tribalsql.com).
LinkedIn: https://www.linkedin.com/in/johnbmcallister/
Contact: http://www.profisee.com
John McAllister co-founded Stratature, an Independent MDM software vendor, in 2001. Following Microsoft’s acquisition of Stratature in 2007 John served as Group Program Manager for MDS and oversaw the incorporation of MDM into SQL Server. John now serves as the Regional Sales Director for Profisee, Inc. which provides enterprise-class MDM Solutions built on top of Microsoft’s MDS offering. John has worked with 100’s of organizations around the world in all phases of MDM projects.
LinkedIn: https://www.linkedin.com/pub/david-sumlin/3/2b0/49
David is currently a Senior Database Architect and Consultant within the Enterprise Data amp; Analytics group at Wells Fargo. He has been developing data driven applications and working with SQL Server and many other RDBMS for the last 15 years. He has implemented both small and large OLTP applications as well as large DSS data warehouses.
Contact: http://www.benjaminnevarez.com/
Benjamin Nevarez is a SQL Server MVP and independent consultant based in Los Angeles, California who specializes in SQL Server query tuning and optimization. He is the author of “SQL Server 2014 Query Tuning Optimization”, “Inside the SQL Server Query Optimizer” and has contributed to other SQL Server books including “SQL Server 2012 Internals”. Benjamin has also been a speaker at many SQL Server conferences, including the PASS Summit, SQL Server Connections and SQLBits.
LinkedIn: http://www.linkedin.com/in/sqlrockstar/
Contact: http://thomaslarock.com
Thomas LaRock is a Head Geek at SolarWinds and a Microsoft Certified Master, Data Platform MVP, VMware vExpert, and a Microsoft Certified Trainer. He has over 15 years’ experience in the IT industry in roles including programmer, developer, analyst, and database administrator.
Dania Jones is a SQL Server Specialist with Microsoft supporting customers with their advancements and maintenance of the Microsoft database platform. She joined Microsoft 3 years ago following 15 years in the IT industry supporting database platforms and services for global organizations. Prior to Microsoft, she worked across a wide range of opportunities including web/software development, DBA services, data analytics and insights, and enterprise resource management.
LinkedIn: http://www.linkedin.com/in/jasonhorner
Contact: http://blog.jasonhorner.com
Hi, my name is Jason I'm a practice lead at Redapt. I spend most of my day helping clients solve business problems mostly in the Data and Advanced Analytics spaces. Sometimes this involves various and sundry cloud technologies including Azure Data Factory, Azure SQL Data Warehouse, Azure Data Lake Store, Azure Databricks, HDInsight and Azure SQL Database. I'm fluent in several languages including: SQL, C#, Python, and PowerShell. I'm a Microsoft Certified Master of SQL Server (MCM) and have been recognized for my technical excellence and evangelism efforts by Microsoft by being awarded the Most Valuable Professional (MVP) for the last 5+ years. In my off hours I like to snowboard, karaoke, ride roller coasters, and play arcade games
LinkedIn: http://www.linkedin.com/in/mickeystuewe/
Contact: http://www.MickeyStuewe.com
Mickey Stuewe has been working with SQL Server since 6.5. That gives her over 20 years of experience. She has not only been a database developer, but also an application developer, even before Visual Studio existed. She is now thankful to be focusing on database design, t-SQL development, and query optimization. She also has a habit of enjoying SSIS and data warehouse design. She blogs regularly on her website mickeystuewe.com and contributes to sites such as SQL Server Central and SQL Server Pro. She enjoys presenting at PASS Summit, SQLSaturdays, User Groups and other events. When she is not immersed in SQL related activities, she enjoys action movies, art, reading, and laughing. She laughs loudly and often...just ask her children.
LinkedIn: https://www.linkedin.com/profile/view?id=176471amp;trk=nav_responsive_tab_profile
Contact: http://mssqlperformance.blogspot.com/
Jeff has been consulting on and performing technical training for MS SQL Server since 1989, Version 4, on OS/2. Since then, he has worked extensively with each release of the product, specializing in performance and tuning, from concept through legacy system, on systems of all sizes, from small start-up company applications to multi-terabyte data warehouses. In addition to hands-on consulting, he speaks at SQLSaturdays several times/year, has a youtube channel with free training, and has written 20 books on database management systems. His latest book is "Transact SQL the Definitive Guide."
LinkedIn: https://www.linkedin.com/in/mrdenny
Contact: https://www.dcac.com
Denny Cherry is the owner and principal consultant for Denny Cherry Associates Consulting and has over a decade of experience working with platforms such as Microsoft Azure, Amazon AWS, Microsoft SQL Server, Hyper-V, vSphere, and Enterprise Storage solutions. Denny’s areas of technical expertise include system architecture, performance tuning, security, replication, and troubleshooting. Denny currently holds several Microsoft Certifications related to SQL Server 2000 through 2019, including being a Microsoft Certified Master, Microsoft MVP and VMware vExpert Award.
I am a SME with the Microsoft Big Data COE team supporting customers in early adoption of Big Data technology. I provide presales support in the areas of "Big Data/BI" and "BI on Cloud"' to various industries including Financial Services, Manufacturing and Environmental. I've received Community recognition for my informative sessions presented at SQLSaturdays on Azure, BI and Big Data. I am an avid supporter of solution selling and continue to contribute in the area of solution-building
LinkedIn: https://www.linkedin.com/in/sqlballs
Contact: http://www.sqlballs.com
Bradley Ball is a Sr. Azure Engineer for Microsoft, and former Data Platform MVP. During his IT career Bradley has spent 8 years working as a Defense contractor for clients such as the U.S. Army and The Executive Office of the President of the United States, and the former Data Platform Practice Manager for Pragmatic Works Consulting. He has presented at SQLSaturdays, SSUG's, SQL Rally, DevConnections, SQLBits, SQL Live 360, and the PASS Summit. Bradley can be found blogging on http://www.SQLBalls.com
LinkedIn: http://www.linkedin.com/in/karenlopez
Contact: http://datamodel.com
Karen Lopez is a Sr. Project Manager and Architect for InfoAdvisors. A frequent speaker at conferences and local user groups, she has 20+ years of experience in project and data management on large, multi-project programs. Karen is a chronic volunteer, a Data Platform MVP, and an active advocate for science, technology, engineering, and mathematics (STEM) education and data quality. Karen’s presentations are known for their lively and interactive approach to learning. Her motto: “Love Your Data!”
LinkedIn: https://www.linkedin.com/profile/view?id=176471amp;trk=nav_responsive_tab_profile
Contact: http://mssqlperformance.blogspot.com/
Jeff has been consulting on and performing technical training for MS SQL Server since 1989, Version 4, on OS/2. Since then, he has worked extensively with each release of the product, specializing in performance and tuning, from concept through legacy system, on systems of all sizes, from small start-up company applications to multi-terabyte data warehouses. In addition to hands-on consulting, he speaks at SQLSaturdays several times/year, has a youtube channel with free training, and has written 20 books on database management systems. His latest book is "Transact SQL the Definitive Guide."
LinkedIn: https://www.linkedin.com/in/mrdenny
Contact: https://www.dcac.com
Denny Cherry is the owner and principal consultant for Denny Cherry Associates Consulting and has over a decade of experience working with platforms such as Microsoft Azure, Amazon AWS, Microsoft SQL Server, Hyper-V, vSphere, and Enterprise Storage solutions. Denny’s areas of technical expertise include system architecture, performance tuning, security, replication, and troubleshooting. Denny currently holds several Microsoft Certifications related to SQL Server 2000 through 2019, including being a Microsoft Certified Master, Microsoft MVP and VMware vExpert Award.
I am a SME with the Microsoft Big Data COE team supporting customers in early adoption of Big Data technology. I provide presales support in the areas of "Big Data/BI" and "BI on Cloud"' to various industries including Financial Services, Manufacturing and Environmental. I've received Community recognition for my informative sessions presented at SQLSaturdays on Azure, BI and Big Data. I am an avid supporter of solution selling and continue to contribute in the area of solution-building
LinkedIn: https://www.linkedin.com/in/kerrytyler
Contact: http://airbornegeek.com
Kerry Tyler is a SQL Server, Business Intelligence, and Azure consultant. His initial IT experience was in network engineering and Windows system administration before moving into the data realm. This infrastructure background builds a firm foundation for performance tuning and cloud infrastructure design and implementation. Kerry has full-time DBA experience in SQL Server since version 2000 and business intelligence architecture since SQL Server 2005. In addition to consulting work, he delivers presentations and training on SQL Server administration, business intelligence, and Azure data and infrastructure components.
LinkedIn: https://www.linkedin.com/in/sqlballs
Contact: http://www.sqlballs.com
Bradley Ball is a Sr. Azure Engineer for Microsoft, and former Data Platform MVP. During his IT career Bradley has spent 8 years working as a Defense contractor for clients such as the U.S. Army and The Executive Office of the President of the United States, and the former Data Platform Practice Manager for Pragmatic Works Consulting. He has presented at SQLSaturdays, SSUG's, SQL Rally, DevConnections, SQLBits, SQL Live 360, and the PASS Summit. Bradley can be found blogging on http://www.SQLBalls.com
I am a SME with the Microsoft Big Data COE team supporting customers in early adoption of Big Data technology. I provide presales support in the areas of "Big Data/BI" and "BI on Cloud"' to various industries including Financial Services, Manufacturing and Environmental. I've received Community recognition for my informative sessions presented at SQLSaturdays on Azure, BI and Big Data. I am an avid supporter of solution selling and continue to contribute in the area of solution-building
LinkedIn: http://www.linkedin.com/in/armordba
Contact: https://armordba.com/
Tom Norman is a Database Architect at KPA with a strong fervor to protect data. He works daily to review and improve data protection methodologies while reviewing governing laws affecting finance, healthcare, and personal data. His areas of expertise include encryption, auditing, data identification, and database object deployment. He is the current leader of the PASS Virtualization Group and Vice President of the TRIPASS user group. You can read his blog at https://armordba.com/ and reach him on twitter at @armordba. Tom speaks at a number of SQLSaturday events and SQL Server user groups.
LinkedIn: http://www.linkedin.com/in/karenlopez
Contact: http://datamodel.com
Karen Lopez is a Sr. Project Manager and Architect for InfoAdvisors. A frequent speaker at conferences and local user groups, she has 20+ years of experience in project and data management on large, multi-project programs. Karen is a chronic volunteer, a Data Platform MVP, and an active advocate for science, technology, engineering, and mathematics (STEM) education and data quality. Karen’s presentations are known for their lively and interactive approach to learning. Her motto: “Love Your Data!”
LinkedIn: http://www.linkedin.com/pub/andy-nakamura/18/12/709/en
Contact: http://andynakamura.com
Andrew Nakamura is a SQL DBA at Keck Medicine of USC. His experience spans enterprise wide level of support using Powershell, DBATools and other custom scripts to maintain 115 servers with over 1600 databases. He has expertise in both Financial and Healthcare worlds and knows the challenges they face. He has presented in all Southern California SQLSaturdays and will continue to push bleeding edge solutions. He enjoys the command line syntax and wish like to play with Core Editions of Windows and SQL 2017. He's added to his current passions of Azure, Automation, High Availability, Family and Faith, Toastmasters, and now, SQL on Linux. Long live the command shell!
LinkedIn: https://www.linkedin.com/in/rob-hatton-3ab4b845
Contact: http://www.RobertJHatton.com
Rob Hatton is the author of the Business Intelligence Team Handbook. Rob is also a past president of the PASS Business Intelligence User Group here in Tampa. He is a veteran B.I. developer with more than 30 years of database experience and dozens of successful B.I. project deployments.
LinkedIn: http://www.linkedin.com/in/dataonwheels
Contact: http://www.dataonwheels.com
Steve Hughes is the Director of Consulting at Pragmatic Works. In his current role, Steve manages the consultant team at Pragmatic Works and directs implementation of our cloud practices for customers. He focuses on team development and company growth with this role. In his previous role as a Principal Consultant Lead, he focused designing solutions for customers on Microsoft technologies including SQL Server, Power BI, and Azure. He has been working with technology for over 20 years with much of that time spent on creating business intelligence solutions and helping customers implement leading BI and cloud solutions. He is passionate about using data effectively and helping customers understand that data is valuable and profitable.
LinkedIn: http://www.linkedin.com/pub/jeff-renz/29/82a/aa4
Contact: http://www.revgen.com
Jeff Renz is a Senior Architect at RevGen Partners, currently working as the design architect and implementation lead on several projects for a Fortune Top 50 company. Jeff has worked with SQL Server and BI for 15+ years and has 10 years’ experience with data warehouse design and implementation. In addition to consulting, he is joining the University of Denver adjunct faculty and is expected to begin teaching in the ICT program starting in June. He received his bachelor’s degree in Computer Science, his master’s degree in Operations Research from Colorado School of Mines, and will be graduating from the Harvard Business Analytics Program in December.
LinkedIn: http://www.linkedin.com/in/mickeystuewe/
Contact: http://www.MickeyStuewe.com
Mickey Stuewe has been working with SQL Server since 6.5. That gives her over 20 years of experience. She has not only been a database developer, but also an application developer, even before Visual Studio existed. She is now thankful to be focusing on database design, t-SQL development, and query optimization. She also has a habit of enjoying SSIS and data warehouse design. She blogs regularly on her website mickeystuewe.com and contributes to sites such as SQL Server Central and SQL Server Pro. She enjoys presenting at PASS Summit, SQLSaturdays, User Groups and other events. When she is not immersed in SQL related activities, she enjoys action movies, art, reading, and laughing. She laughs loudly and often...just ask her children.
LinkedIn: http://www.linkedin.com/in/martinschoombee
Contact: http://www.martinschoombee.com
Martin is an independent Business Intelligence Analytics consultant, helping customers make sense of their data for more than 15 years.
Contact: http://bigdatajoe.io/
“Big Data Joe” is the Engineering Lead and Big Data Architect at Trace3's Big Data Intelligence Practice. Joe is certified in most Hadoop distributions as an administrator, engineer and developer. Joe is the technical Big Data evangelist for Trace3 and speaks at T3’s workshops, training sessions and events. He has 16 years of experience in the IT field as hands-on engineer with startups to Fortune 5 companies. He enjoys sharing his findings and helping others make sense of new technologies.
LinkedIn: http://www.linkedin.com/in/sqlwatchmen
Contact: http://sqlwatchmen.com/blogs/jim/
Jim Murphy has been using Microsoft SQL Server since version 6.0 back in the 90#39;s. He is the CEO of SQLWatchmen, LLC., a managed DBA service provider. He runs the Austin SQL Server User Group: CACTUSS Central. He has been a professional DBA and developer for over 25 years and has run a consulting company full time since 2001.
LinkedIn: http://www.linkedin.com/in/armordba
Contact: https://armordba.com/
Tom Norman is a Database Architect at KPA with a strong fervor to protect data. He works daily to review and improve data protection methodologies while reviewing governing laws affecting finance, healthcare, and personal data. His areas of expertise include encryption, auditing, data identification, and database object deployment. He is the current leader of the PASS Virtualization Group and Vice President of the TRIPASS user group. You can read his blog at https://armordba.com/ and reach him on twitter at @armordba. Tom speaks at a number of SQLSaturday events and SQL Server user groups.
i like computers and synthesizers and cats
LinkedIn: http://www.linkedin.com/in/sqlwatchmen
Contact: http://sqlwatchmen.com/blogs/jim/
Jim Murphy has been using Microsoft SQL Server since version 6.0 back in the 90#39;s. He is the CEO of SQLWatchmen, LLC., a managed DBA service provider. He runs the Austin SQL Server User Group: CACTUSS Central. He has been a professional DBA and developer for over 25 years and has run a consulting company full time since 2001.
LinkedIn: http://www.linkedin.com/in/martinschoombee
Contact: http://www.martinschoombee.com
Martin is an independent Business Intelligence Analytics consultant, helping customers make sense of their data for more than 15 years.
LinkedIn: http://www.linkedin.com/in/sqlwatchmen
Contact: http://sqlwatchmen.com/blogs/jim/
Jim Murphy has been using Microsoft SQL Server since version 6.0 back in the 90#39;s. He is the CEO of SQLWatchmen, LLC., a managed DBA service provider. He runs the Austin SQL Server User Group: CACTUSS Central. He has been a professional DBA and developer for over 25 years and has run a consulting company full time since 2001.
LinkedIn: http://www.linkedin.com/in/tameraclark/
Contact: http://tameraclark.com
Tamera Clark has been involved in the IT industry for greater than ten years, with experiences ranging from systems analysis/engineering to SQL Server and SSRS administration/development. She is an active member of the SQL Server community, participating in the Women in Technology Virtual Chapter, Co-leading the Nashville BI Chapter, assisting the Nashville PASS Chapter and serving as a Regional Mentor. Tamera is also the event chair of SQLSaturday Nashville.
LinkedIn: http://www.linkedin.com/in/dataonwheels
Contact: http://www.dataonwheels.com
Steve Hughes is the Director of Consulting at Pragmatic Works. In his current role, Steve manages the consultant team at Pragmatic Works and directs implementation of our cloud practices for customers. He focuses on team development and company growth with this role. In his previous role as a Principal Consultant Lead, he focused designing solutions for customers on Microsoft technologies including SQL Server, Power BI, and Azure. He has been working with technology for over 20 years with much of that time spent on creating business intelligence solutions and helping customers implement leading BI and cloud solutions. He is passionate about using data effectively and helping customers understand that data is valuable and profitable.
LinkedIn: http://www.linkedin.com/in/brentgreenwood
Contact: http://brentgreenwood.blogspot.com/
Brent Greenwood, MS, MCITP, CBIP, is a PowerPivot junkie and long-time Microsoft BI Pro with 13+ years of experience in the data analysis, data warehousing, and business intelligence crafts. He's delivered solutions and worn lots of different hats in a variety of verticals, including Investment Management, Brokerage, Insurance Services, Healthcare, and Higher Education. Most importantly, Brent is a cycling enthusiast and loves riding and building prototypes with AdventureWorks cycling data.
The following is a list of sponsors that helped fund the event.


Timer
minutes
minutes
minutes
Number of focus sessions between long breaks.
rounds
Appearance
Accent Color:
Sounds & Notifications
Make sure that your browser allows notifications from this site.
If enabled, white noise will be played during focus sessions. Make sure that your browser allows sound from this site.
Backup and Restore
About Tomodoro
Tomodoro is an open source pomodoro web app with features like offline support and PIP mode.
View on GitHub
About PIP mode
Tomodoro supports Always on Top mode, or Picture-In-Picture mode, right in the browser, without having to install any electron app.PIP mode is supported on Chromium based browsers(Tested on Chrome and Edge).
Safari not tested (yet) but might work.
On desktop Firefox, PIP button will only make the video visible but will not activate PIP. To switch to PIP mode, right click on the video and select "Watch in Picture-In-Picture".


{% csrf_token %}
Toggle navigation
home
deals
coupons
contact
logout
all categories
food
Andhra
Italain
Chinese
American
Mexican
Punjabi
clothing
men's
women's
kid's
saloon & spa
Hair styles
spa
Facials
Manicure & padicure
groceries
Travel & education
tickets
cabs
tutions
trainings
jewellery
gold
silver
diamonds
Mobiles and electronics
Mobiles
laptops & pcs
Gadgets
home and kitchen
Kitchen appliances
furniture
{% for k in deals %} {% for h in k.img_id %}
50% OFF
{{k.description}}
Store : {{k.company}}
OFFER : {{k.coupon_type}}
{% endfor %} {% endfor %}
latest deals
view all
{% for k in deals %} {% for h in k.img_id %}
{{k.code}}
{{k.description}}
Store : {{k.company}}
Expires: {{k.Validity|date:"D d M Y"}}
offer: {{k.coupon_type}}
{% endfor %} {% endfor %}
today's trending offers
{% for k in todays %} {% for h in k.img_id %}
{{k.code}}
{{k.description}}
store:
{{k.company}}
Expires in:
{{k.Validity|date:"D d M Y"}}
store:
{{k.coupon_type}}
{% endfor %} {% endfor %}
popular stores
{% for i in stores %}
{% endfor %}
over 400+ coupons available
{% for k in coupons %} {% for h in k.img_id %}
{{k.description}}
Stores
-{{k.company}}
expires :
{{k.Validity|date:"D d M Y"}}
Couponcode :
{{k.code}}
offer :
{{k.coupon_type}}
{% endfor %} {% endfor %}
2017 Best Buy - Discount and coupons


Source code for benchbuild.statistics
"""
Handle all statsitic related classes and methods.
"""
import logging
from benchbuild.extensions import Extension
from benchbuild.utils.schema import Session
# The import of scipy and all of its usages are commented out, since its import
# takes too much time for the buildbot. To use the statistics uncomment the
# import and the line containing the stats.ttest function of scipy.
# import scipy
LOG = logging.getLogger(__name__)
TIMEOUT = 1
[docs]class Statistics(Extension):
"""
Extend a run to be repeated until it reaches a statistically significance
specified by the user.
An example on how to use this extension can be found in the Pollytest
Experiment.
"""
def __init__(self, project, experiment, *extensions, config=None):
self.project = project
self.experiment = experiment
super(Statistics, self).__init__(*extensions, config=config)
[docs] def t_test(self, *results, significance=0.95):
"""
Runs a t-test on a given set of results.
Returns:
True if the null hypothesis that the result was not significant
was rejected, False otherwise.
"""
for result in results:
del result # Unused temporarily
t_statistic = 0
p_value = 0
#t_statistic, p_value = scipy.stats.ttest_1samp(result, TRUE_MU)
LOG.debug("t-statistic = %f, pvalue = %f", t_statistic, p_value)
return p_value >= 1 - significance
def __call__(self, *args, timeout=TIMEOUT, **kwargs):
"""
The call of this extension runs the following extensions until the
timeout was reached or a run was significant enough to withdraw the
nullhypothesis.
Kwargs:
timeout: The amount of trys the user wants to give the experiment
before it gets interrupted.
Returns:
The run info object after executing the
afterwards following extensions.
"""
iterator = 0
session = Session()
while iterator < timeout:
#get an run_info object after executing the run with its extensions
ri_object = self.call_next(*args, **kwargs)
#check if the experiment defines the result function
if hasattr(self.experiment, 'res_func'):
results = self.experiment.res_func(ri_object)
if self.t_test(results):
LOG.info("The run was significant.")
break
#check if this was the last iteration
if iterator == (timeout - 1):
LOG.warning(
"No significant run happened before the timeout!")
iterator += 1
# no need to repeat the run without a result function
else:
break
#Commit the database session containing all runs
session.commit()
LOG.info("Overall one command was executed %s times.", iterator)
return ri_object


Copper prices are expected to trade sideways today: Angel Broking
According to Angel Broking, Copper On Tuesday, copper prices on the LME ended higher by 0.77 percent to close at $5875.0 per tonne.
Angel Broking's report on Copper
Copper On Tuesday, copper prices on the LME ended higher by 0.77 percent to close at $5875.0 per tonne. Prices gained reflecting an uptrend in Shanghai copper after China’s central bank announced to provide more stimulus measures to try and get their economy back on track.
Outlook
No concrete outcome of the U.S.-China trade spat might weigh on the market sentiments and push the prices lower. On the MCX, Copper prices are expected to trade sideways today; international markets trading lower by 0.17 percent at $5871.5 per tonne.
For all commodities report, click here
Disclaimer: The views and investment tips expressed by investment experts/broking houses/rating agencies on moneycontrol.com are their own, and not that of the website or its management. Moneycontrol.com advises users to check with certified experts before taking any investment decisions.


Yesterday, I spent some time on preparing a screencast of PySolFC auto-solving a deal of Freecell using Freecell Solver . Here's an embedded player:
I remember the first time I saw KDE's KPatience automatically solving a deal of Freecell, while using Freecell Solver as its back-end. Seeing the cards move on their own was very cool, and brought me a lot of joy. Now that PySolFC has built-in support for Freecell Solver, I was able to use it to prepare the screencast. I hope you'll enjoy seeing this screencast, and would be interested in trying out PySolFC and Freecell Solver.
I'm going to blog about how I prepared the screencast on my tech blog, which may prove instructive to other people wanting to prepare screencasts on Linux. This was the first video I ever prepared and producing it proved to be a pleasant experience, even though some tasks did not work right away.


Additional scales used in the Framework for Routine Outcome Measurement
in Liaison Psychiatry (FROM-LP)
Includues:
- IRAC: Identify and Rate the Aim of the Contact (Trigwell P, 2014a).
- CGI-I: Clinical Global Impression – Improvement scale (Guy W, 1976);
see CGI.
- CORE-10 — but while paper copies are free, electronic reproduction is
not: see
http://www.coreims.co.uk/copyright.pdf.
- Patient Satisfaction Scale (Persaud A et al. 2008).
- Friends and Family Test (Department of Health, 2012).
- Referrer Satisfaction Scale (Trigwell P, 2014b, after Persaud A et al.
2008).
History and guide
Source
- FROM-LP report (2015), as above, and some original sources.
Intellectual property rights
- 2015 faculty report © The Royal College of Psychiatrists.
- “... the actual FROM-LP framework. The scales named in the latter” [the
FROM-LP framework] “are all fine to use from a copyright perspective.”
Peter Trigwell, clinical lead for FROM-LP, to Rudolf Cardinal
2015-06-01.
- However, the CORE-10 isn’t, in an electronic context, as noted
above.


Integrations
This feature guide was contributed by the team at based on their experience of integrating over 180 different SaaS applications with their product.
Enterprises are complex entities composed of a variety of teams and the applications they like to use. These applications generate valuable business data that, when sent to other tools or combined with other data, is far more useful. For these enterprises to reduce organizational communication overhead and maintain business agility, it’s integral for those applications to be able to work together.
The value proposition of these application SaaS companies to get critical data in and out have been increasingly clear for enterprises. While having a well-documented API is an important foundation necessary for achieving interoperability, the easier it is for users to get the data they need where they need it, the more adoption you’ll achieve.
At the most basic level
Export - This is the most basic way for enterprise users to access the raw data they need so that they can analyze it on their own, import it into another tool, or ease concerns around vendor lock-in. Exporting data can be self-service (where the user presses a button in your application) or manual (where the user emails your support staff for them to retrieve and provide the data).
API - Providing a publicly accessible endpoint for any end user to query and retrieve data allows for further flexibility. Many enterprises have complex needs and oftentimes leverage SaaS tools within a specific workflow. An easy access API is valuable in that enterprises can build their own solutions with the data in your service.
API access is also important if your service benefits from receiving data from other services. Making it as easy as possible for end users to get the most value out of your service is critical.
Webhook notification - Webhooks is similar to an API in that they can be easily incorporated into other workflows. However, these notifications typically reflect the important events in your application, e.g. something stopped working, or data is no longer being sent. While in app notifications are great, providing those same notifications via outbound webhooks allows users to integrate your service into their collaboration tools such as Slack.
Advanced functionality
The more advanced functionalities around providing integrations for enterprises reflects the unique ways larger teams use SaaS solutions and the data they generate.
Admin control over integrations - Like any other enterprise SaaS solution that serves a variety of users, providing granular role based access control for enabling integrations. Not all users need to be able to enable or disable integrations for your tool, so allow their admin to set the proper permissions for their team.
Enabled integrations tied to the right “object” - The enabled integration should be tied to the right object depending on your service. In most cases, the integration should be tied to the user’s organization, a specific “project”, or “workspace” in your service. Suppose that integration is tied to the user, if the user removes her account, then the enabled integration would no longer serve the needs of the larger organization or project.
Discoverability of integrations - Thinking holistically about how users will interact with your service will help identify the most reasonable places in their flow to remind them of your available integrations. This can be during the setup and onboarding flow, or have it’s own section in your documentation, or even embedded in your partners’ onboarding.
Ease of use - Enterprises value time and will typically prefer enabling integrations with a few mouse clicks than having to talk to a human or download a raw .csv file. Understanding which services your users need your data in and making that data flow as frictionless as possible will dramatically increase the value of your service.
Building strategic integrations - However, to increase both the value of your service and your user base, it helps to identify the main tools or applications your target end users use and building integrations directly with them. Additionally, it helps to build connectors to the most popular tools, such as Slack, Zapier, or Amazon Redshift.


| Home | Trees | Indices | Help |
|
|---|
|
|
object --+ | declaration.declaration_t --+ | scopedef_t
Base class for namespace_t and class_t classes.
This is the base class for all declaration classes that may have
children nodes. The children can be accessed via the
declarations
property.
Also this class provides "get/select/find" interface. Using this class you can get instance or instances of internal declaration(s).
You can find declaration(s) using next criteria:Every "select" API you can invoke and pass as first argument at declaration name or function. This class will find out correctly what argument represents.
Example:ns - referrers to global namespace ns.member_function( "do_something ) - will return reference to member function named "do_something". If there is no such function exception will be raised. If there is more then one function exception will be raised too.Example 2:
ns - referers to global namespace do_smths = ns.member_functions( "do_something ) - will return instance of L{mdecl_wrapper_t} object. This object allows you few things: 1. To iterate on selected declarations 2. To set some property to desired value using one line of code only: do_smths.call_policies = x 3. To call some function on every instance using one line of code: do_smths.exclude() Pay attention: you can not use "get" functions or properties.
|
|||
|
__init__(self,
name='') x.__init__(...) initializes x; see x.__class__.__doc__ for signature |
|||
|
__eq__(self,
other) function will return true, if both declarations refers to the same object. |
|||
| remove_declaration(self, decl) | |||
|
clear_optimizer(self) Cleans query optimizer state |
|||
|
init_optimizer(self) Initializes query optimizer state. |
|||
|
decl(self,
name=None,
function=None,
decl_type=None,
header_dir=None,
header_file=None,
recursive=None) returns reference to declaration, that is matched defined criterias |
|||
|
decls(self,
name=None,
function=None,
decl_type=None,
header_dir=None,
header_file=None,
recursive=None,
allow_empty=None) returns a set of declarations, that are matched defined criterias |
|||
|
class_(self,
name=None,
function=None,
header_dir=None,
header_file=None,
recursive=None) returns reference to class declaration, that is matched defined criterias |
|||
|
classes(self,
name=None,
function=None,
header_dir=None,
header_file=None,
recursive=None,
allow_empty=None) returns a set of class declarations, that are matched defined criterias |
|||
|
variable(self,
name=None,
function=None,
type=None,
header_dir=None,
header_file=None,
recursive=None) returns reference to variable declaration, that is matched defined criterias |
|||
|
variables(self,
name=None,
function=None,
type=None,
header_dir=None,
header_file=None,
recursive=None,
allow_empty=None) returns a set of variable declarations, that are matched defined criterias |
|||
|
calldef(self,
name=None,
function=None,
return_type=None,
arg_types=None,
header_dir=None,
header_file=None,
recursive=None) returns reference to "calldef" declaration, that is matched defined criterias |
|||
|
calldefs(self,
name=None,
function=None,
return_type=None,
arg_types=None,
header_dir=None,
header_file=None,
recursive=None,
allow_empty=None) returns a set of calldef declarations, that are matched defined criterias |
|||
|
operator(self,
name=None,
function=None,
symbol=None,
return_type=None,
arg_types=None,
header_dir=None,
header_file=None,
recursive=None) returns reference to operator declaration, that is matched defined criterias |
|||
|
operators(self,
name=None,
function=None,
symbol=None,
return_type=None,
arg_types=None,
header_dir=None,
header_file=None,
recursive=None,
allow_empty=None) returns a set of operator declarations, that are matched defined criterias |
|||
|
member_function(self,
name=None,
function=None,
return_type=None,
arg_types=None,
header_dir=None,
header_file=None,
recursive=None) returns reference to member declaration, that is matched defined criterias |
|||
|
member_functions(self,
name=None,
function=None,
return_type=None,
arg_types=None,
header_dir=None,
header_file=None,
recursive=None,
allow_empty=None) returns a set of member function declarations, that are matched defined criterias |
|||
|
constructor(self,
name=None,
function=None,
return_type=None,
arg_types=None,
header_dir=None,
header_file=None,
recursive=None) returns reference to constructor declaration, that is matched defined criterias |
|||
|
constructors(self,
name=None,
function=None,
return_type=None,
arg_types=None,
header_dir=None,
header_file=None,
recursive=None,
allow_empty=None) returns a set of constructor declarations, that are matched defined criterias |
|||
|
member_operator(self,
name=None,
function=None,
symbol=None,
return_type=None,
arg_types=None,
header_dir=None,
header_file=None,
recursive=None) returns reference to member operator declaration, that is matched defined criterias |
|||
|
member_operators(self,
name=None,
function=None,
symbol=None,
return_type=None,
arg_types=None,
header_dir=None,
header_file=None,
recursive=None,
allow_empty=None) returns a set of member operator declarations, that are matched defined criterias |
|||
|
casting_operator(self,
name=None,
function=None,
return_type=None,
arg_types=None,
header_dir=None,
header_file=None,
recursive=None) returns reference to casting operator declaration, that is matched defined criterias |
|||
|
casting_operators(self,
name=None,
function=None,
return_type=None,
arg_types=None,
header_dir=None,
header_file=None,
recursive=None,
allow_empty=None) returns a set of casting operator declarations, that are matched defined criterias |
|||
|
enumeration(self,
name=None,
function=None,
header_dir=None,
header_file=None,
recursive=None) returns reference to enumeration declaration, that is matched defined criterias |
|||
|
enum(self,
name=None,
function=None,
header_dir=None,
header_file=None,
recursive=None) adding small aliase to enumeration method |
|||
|
enumerations(self,
name=None,
function=None,
header_dir=None,
header_file=None,
recursive=None,
allow_empty=None) returns a set of enumeration declarations, that are matched defined criterias |
|||
|
enums(self,
name=None,
function=None,
header_dir=None,
header_file=None,
recursive=None,
allow_empty=None) returns a set of enumeration declarations, that are matched defined criterias |
|||
|
typedef(self,
name=None,
function=None,
header_dir=None,
header_file=None,
recursive=None) returns reference to typedef declaration, that is matched defined criterias |
|||
|
typedefs(self,
name=None,
function=None,
header_dir=None,
header_file=None,
recursive=None,
allow_empty=None) returns a set of typedef declarations, that are matched defined criterias |
|||
|
__getitem__(self,
name_or_function) Allow simple name based find of decls. |
|||
|
Inherited from Inherited from |
|
|||
RECURSIVE_DEFAULT = True
|
|||
ALLOW_EMPTY_MDECL_WRAPPER = False
|
|
|||
| list of declaration_t |
declarations A list of children declarations. |
||
|
Inherited from Inherited from |
|
x.__init__(...) initializes x; see x.__class__.__doc__ for signature
|
function will return true, if both declarations refers to the same object. This function could be implemented in terms of _get__cmp__data, but in this case it will downgrade performance. self.mangled property is not compared, because it could be chaned from one compilation time to an other.
|
|
Cleans query optimizer state |
Initializes query optimizer state. There are 4 internals hash tables: |
returns reference to declaration, that is matched defined criterias |
returns a set of declarations, that are matched defined criterias |
returns reference to class declaration, that is matched defined criterias |
returns a set of class declarations, that are matched defined criterias |
returns reference to variable declaration, that is matched defined criterias |
returns a set of variable declarations, that are matched defined criterias |
returns reference to "calldef" declaration, that is matched defined criterias |
returns a set of calldef declarations, that are matched defined criterias |
returns reference to operator declaration, that is matched defined criterias |
returns a set of operator declarations, that are matched defined criterias |
returns reference to member declaration, that is matched defined criterias |
returns a set of member function declarations, that are matched defined criterias |
returns reference to constructor declaration, that is matched defined criterias |
returns a set of constructor declarations, that are matched defined criterias |
returns reference to member operator declaration, that is matched defined criterias |
returns a set of member operator declarations, that are matched defined criterias |
returns reference to casting operator declaration, that is matched defined criterias |
returns a set of casting operator declarations, that are matched defined criterias |
returns reference to enumeration declaration, that is matched defined criterias |
adding small aliase to enumeration method |
returns a set of enumeration declarations, that are matched defined criterias |
returns a set of enumeration declarations, that are matched defined criterias |
returns reference to typedef declaration, that is matched defined criterias |
returns a set of typedef declarations, that are matched defined criterias |
Allow simple name based find of decls. Internally just calls decls() method. @param name_or_function Name of decl to lookup or finder function. |
|
RECURSIVE_DEFAULT
|
ALLOW_EMPTY_MDECL_WRAPPER
|
|
declarationsA list of children declarations.
|
| Home | Trees | Indices | Help |
|
|---|
| Generated by Epydoc 3.0alpha3 on Thu Oct 19 08:14:27 2006 | http://epydoc.sourceforge.net |