Large refactoring in data provider

Author: avz

src/DataProvider.js

@@ -0,0 +1,99 @@
+'use strict';
+
+const DataSource = require('./DataSource');
+const DataSourceRead = require('./dataSource/DataSourceRead');
+const ProgramError = require('./error/ProgramError');
+
+class DataProvider
+{
+	/**
+	 *
+	 * @param {DataSourceAnalyzer} dataSourceAnalyzer
+	 */
+	constructor(dataSourceAnalyzer)
+	{
+		this.dataSourceAnalyzer = dataSourceAnalyzer;
+	}
+
+	/**
+	 * @public
+	 * @param {SqlNodes.Table} tableNode
+	 * @returns {DataSource}
+	 */
+	getDataSource(tableNode)
+	{
+		const chain = this.dataSourceAnalyzer.createCallChain(tableNode.source);
+		const streamsChain = this.createStreamsChain(chain);
+		const stream = this.createResultStream(streamsChain);
+
+		const resolvedAlias = streamsChain[streamsChain.length - 1].alias;
+		const alias = (tableNode.alias && tableNode.alias.name) || resolvedAlias;
+
+		return new DataSource(stream, alias);
+	}
+
+	/**
+	 * @private
+	 * @param {DataSourceRead|DataSourceTransform} start
+	 * @returns {stream.Readable[]}
+	 */
+	createStreamsChain(start)
+	{
+		if (start instanceof DataSourceRead) {
+			return [this.createStream(start.desc, start.location, start.options)];
+		}
+
+		const source = this.createStreamsChain(start.input);
+
+		const transform = this.createStream(start.desc, source[source.length - 1], start.options);
+
+		return source.concat([transform]);
+	}
+
+	/**
+	 * @private
+	 * @param {stream.Readable[]} streamsChain
+	 * @returns {stream.Readable}
+	 */
+	createResultStream(streamsChain)
+	{
+		if (!streamsChain.length) {
+			throw new ProgramError('Empty streams chain');
+		}
+
+		var end = streamsChain[0].stream;
+
+		for (let i = 1; i < streamsChain.length; i++) {
+			end = end.pipe(streamsChain[i].stream);
+		}
+
+		return end;
+	}
+
+	/**
+	 * @private
+	 * @param {DataFunctionDescription} desc
+	 * @param {mixed} source
+	 * @param {Object} options
+	 * @returns {DataSource}
+	 */
+	createStream(desc, source, options)
+	{
+		const s = desc.createStream(source, options);
+		var dataSource;
+
+		if (s instanceof DataSource) {
+			dataSource = s;
+		} else {
+			dataSource = new DataSource(s);
+		}
+
+		if (source instanceof DataSource) {
+			dataSource.alias = source.alias;
+		}
+
+		return dataSource;
+	}
+}
+
+module.exports = DataProvider;

src/DataSource.js

@@ -19,5 +19,7 @@ class DataSource
 }
 
 DataSource.DEFAULT_NAME = '@';
+DataSource.TYPE_OBJECTS = 'objects';
+DataSource.TYPE_BINARY = 'binary';
 
 module.exports = DataSource;

src/DataSourceResolversPool.js

@@ -1,6 +1,6 @@
 'use strict';
 
-const SqlNodes = require('./sql/Nodes');
+const DataSource = require('./DataSource');
 
 class DataSourceResolversPool
 {
@@ -30,29 +30,17 @@ class DataSourceResolversPool
 			const source = resolver._resolve(pathFragments);
 
 			if (source) {
-				return source;
+				if (source instanceof DataSource) {
+					return source;
+				} else {
+					return new DataSource(source, resolver.extractAlias(pathFragments));
+				}
 			}
 		}
 
 		return null;
 	}
 
-	/**
-	 *
-	 * @param {ComplexIdent} complexIdent
-	 * @returns {string}
-	 */
-	extractBindingAlias(complexIdent)
-	{
-		const lastFragment = complexIdent.fragments[complexIdent.fragments.length - 1];
-
-		if (lastFragment instanceof SqlNodes.BindingIdent || lastFragment instanceof SqlNodes.BindingIdentList) {
-			return lastFragment.basename();
-		}
-
-		return null;
-	}
-
 	/**
 	 *
 	 * @param {string[]} pathFragments

src/Engine.js

@@ -3,44 +3,68 @@
 const SqlParser = require('./sql/Parser');
 const SqlNodes = require('./sql/Nodes');
 const SqlToJs = require('./SqlToJs');
+
 const PreparingContext = require('./PreparingContext');
 const RuntimeContext = require('./RuntimeContext');
 const FunctionsMap = require('./FunctionsMap');
+
+const DataSourceNotFound = require('./error/DataSourceNotFound');
+
+const DataSource = require('./DataSource');
+const DataSourceApiResolver = require('./DataSourceApiResolver');
+const DataSourceResolversPool = require('./DataSourceResolversPool');
+const DataProvider = require('./DataProvider');
+const DataSourceAnalyzer = require('./dataSource/DataSourceAnalyzer');
+const DataFunctionsRegistry = require('./dataSource/DataFunctionsRegistry');
+const DataFunctionDescription = require('./dataSource/DataFunctionDescription');
+
 const Select = require('./Select');
 const Insert = require('./Insert');
 const Update = require('./Update');
+
 const path = require('path');
 
 class Engine
 {
 	/**
 	 *
-	 * @param {string} sql
 	 * @param {PublicApiOptions} options
+	 */
+	constructor(options = {})
+	{
+		this.options = options;
+		this.functionsMap = this.createFunctionsMap();
+	}
+
+	/**
+	 *
+	 * @param {string} sql
+	 * @param {DataSourceApiResolver} dataSourceInternalResolver
 	 * @returns {Select|Insert}
 	 */
-	createQuery(sql, options = {})
+	createQuery(sql, dataSourceInternalResolver = new DataSourceApiResolver())
 	{
-		const functionsMap = this.createFunctionsMap();
-		const runtimeContext = new RuntimeContext(functionsMap);
+		const runtimeContext = new RuntimeContext(this.functionsMap);
 
 		const sqlToJs = new SqlToJs(
-			functionsMap,
+			this.functionsMap,
 			runtimeContext
 		);
 
 		const preparingContext = new PreparingContext(
 			sqlToJs,
-			functionsMap
+			this.functionsMap
 		);
 
-		preparingContext.options = options;
+		const dataProvider = this.createDataProvider(sqlToJs, dataSourceInternalResolver);
+
+		preparingContext.options = this.options;
 
 		const ast = SqlParser.parse(sql);
 
 		if (ast instanceof SqlNodes.Select) {
 
-			return new Select(preparingContext, runtimeContext, ast);
+			return new Select(dataProvider, preparingContext, runtimeContext, ast);
 		} else if (ast instanceof SqlNodes.Delete) {
 			const selectAst = new SqlNodes.Select;
 
@@ -50,18 +74,53 @@ class Engine
 				selectAst.where = new SqlNodes.Boolean(false);
 			}
 
-			return new Select(preparingContext, runtimeContext, selectAst);
+			return new Select(dataProvider, preparingContext, runtimeContext, selectAst);
 		} else if (ast instanceof SqlNodes.Insert) {
 
-			return new Insert(preparingContext, runtimeContext, ast);
+			return new Insert(dataProvider, preparingContext, runtimeContext, ast);
 		} else if (ast instanceof SqlNodes.Update) {
 
-			return new Update(preparingContext, runtimeContext, ast);
+			return new Update(dataProvider, preparingContext, runtimeContext, ast);
 		} else {
 			throw new Error('Unknown query: ' + ast.constructor.name);
 		}
 	}
 
+	createDataProvider(sqlToJs, dataSourceInternalResolver)
+	{
+		const pool = new DataSourceResolversPool;
+
+		if (this.options.dataSourceResolvers) {
+			for (const resolver of this.options.dataSourceResolvers) {
+				pool.add(resolver);
+			}
+		}
+
+		pool.add(dataSourceInternalResolver);
+
+		const dataFunctionsRegistry = new DataFunctionsRegistry();
+
+		dataFunctionsRegistry.add(new DataFunctionDescription(
+			DataFunctionDescription.TYPE_READ,
+			'INTERNAL',
+			(location, options) => {
+				const dataSource = pool.resolve(location);
+
+				if (!dataSource) {
+					throw new DataSourceNotFound(location);
+				}
+
+				return dataSource;
+			},
+			null,
+			DataSource.TYPE_OBJECTS
+		));
+
+		const dataSourceAnalyzer = new DataSourceAnalyzer(sqlToJs, dataFunctionsRegistry, 'INTERNAL', null);
+
+		return new DataProvider(dataSourceAnalyzer);
+	}
+
 	/**
 	 * @@returns {FunctionsMap}
 	 */

src/Insert.js

@@ -6,24 +6,23 @@ const DataRow = require('./DataRow');
 class Insert
 {
 	/**
-	 *
+	 * @param {DataProvider} dataProvider
 	 * @param {PreparingContext} preparingContext
 	 * @param {RuntimeContext} runtimeContext
 	 * @param {Node} ast
 	 */
-	constructor(preparingContext, runtimeContext, ast)
+	constructor(dataProvider, preparingContext, runtimeContext, ast)
 	{
+		this.dataProvider = dataProvider;
 		this.preparingContext = preparingContext;
 		this.runtimeContext = runtimeContext;
 		this.ast = ast;
 	}
 
 	/**
-	 *
-	 * @param {DataSourceResolversPool} dataSourceResolversPool
 	 * @returns {Append}
 	 */
-	stream(dataSourceResolversPool)
+	stream()
 	{
 		const dummyRow = new DataRow({});
 		const rows = [];

src/PublicApi.js

@@ -3,6 +3,7 @@
 const Engine = require('./Engine');
 const PublicSelect = require('./public/PublicSelect');
 const PublicApiOptions = require('./PublicApiOptions');
+const DataSourceApiResolver = require('./DataSourceApiResolver');
 const Explainer = require('./Explainer');
 
 class PublicApi
@@ -19,7 +20,7 @@ class PublicApi
 			this.options = new PublicApiOptions(options);
 		}
 
-		this.engine = new Engine();
+		this.engine = new Engine(this.options);
 	}
 
 	/**
@@ -29,7 +30,9 @@ class PublicApi
 	 */
 	query(sql)
 	{
-		return new PublicSelect(this.engine.createQuery(sql, this.options), this.options.dataSourceResolvers);
+		const dataSourceInternalResolver = new DataSourceApiResolver();
+
+		return new PublicSelect(this.engine.createQuery(sql, dataSourceInternalResolver), dataSourceInternalResolver);
 	}
 
 	explain(select)